├── .gitignore
├── .github
    ├── FUNDING.yml
    ├── ISSUE_TEMPLATE
    │   ├── custom.md
    │   ├── feature_request.md
    │   └── bug_report.md
    └── workflows
    │   ├── x86_64-apple-darwin.yml
    │   ├── aarch64-apple-darwin.yml
    │   ├── x86_64-pc-windows-msvc.yml
    │   └── x86_64-unknown-linux-gnu.yml
├── .vscode
    └── settings.json
├── deno.json
├── deps.ts
├── combine.ts
├── index.html
├── extract.ts
├── mod.ts
├── check.ts
├── mirrorArticle.ts
├── util.ts
├── search.ts
├── index.xsl
├── README.md
├── get.ts
├── model.ts
├── LICENSE
├── mirror.ts
└── serve.ts


/.gitignore:
--------------------------------------------------------------------------------
1 | dist
2 | .env
3 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 | 
3 | github: [abusenet]
4 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |   "deno.enable": true,
3 |   "deno.lint": true,
4 |   "deno.unstable": true
5 | }
6 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/custom.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Custom issue template
3 | about: Describe this issue template's purpose here.
4 | title: ''
5 | labels: ''
6 | assignees: ''
7 | 
8 | ---
9 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this project
 4 | title: ''
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Is your feature request related to a problem? Please describe.** A clear and
11 | concise description of what the problem is. Ex. I'm always frustrated when [...]
12 | 
13 | **Describe the solution you'd like** A clear and concise description of what you
14 | want to happen.
15 | 
16 | **Describe alternatives you've considered** A clear and concise description of
17 | any alternative solutions or features you've considered.
18 | 
19 | **Additional context** Add any other context or screenshots about the feature
20 | request here.
21 | 


--------------------------------------------------------------------------------
/deno.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "tasks": {
 3 |     "compile:": "deno task compile:x86_64-unknown-linux-gnu && deno task compile:x86_64-pc-windows-msvc && deno task compile:x86_64-apple-darwin && deno task compile:aarch64-apple-darwin",
 4 |     "compile:x86_64-unknown-linux-gnu": "deno compile --target x86_64-unknown-linux-gnu --output dist/nzb-x86_64-unknown-linux-gnu --allow-env --allow-read --allow-write --allow-net mod.ts",
 5 |     "compile:x86_64-pc-windows-msvc": "deno compile --target x86_64-pc-windows-msvc --output dist/nzb-x86_64-pc-windows-msvc.exe --allow-env --allow-read --allow-write --allow-net mod.ts",
 6 |     "compile:x86_64-apple-darwin": "deno compile --target x86_64-apple-darwin --output dist/nzb-x86_64-apple-darwin --allow-env --allow-read --allow-write --allow-net mod.ts",
 7 |     "compile:aarch64-apple-darwin": "deno compile --target aarch64-apple-darwin --output dist/nzb-aarch64-apple-darwin --allow-env --allow-read --allow-write --allow-net mod.ts"
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug** A clear and concise description of what the bug is.
11 | 
12 | **To Reproduce** Steps to reproduce the behavior:
13 | 
14 | 1. Go to '...'
15 | 2. Click on '....'
16 | 3. Scroll down to '....'
17 | 4. See error
18 | 
19 | **Expected behavior** A clear and concise description of what you expected to
20 | happen.
21 | 
22 | **Screenshots** If applicable, add screenshots to help explain your problem.
23 | 
24 | **Desktop (please complete the following information):**
25 | 
26 | - OS: [e.g. iOS]
27 | - Browser [e.g. chrome, safari]
28 | - Version [e.g. 22]
29 | 
30 | **Smartphone (please complete the following information):**
31 | 
32 | - Device: [e.g. iPhone6]
33 | - OS: [e.g. iOS8.1]
34 | - Browser [e.g. stock browser, safari]
35 | - Version [e.g. 22]
36 | 
37 | **Additional context** Add any other context about the problem here.
38 | 


--------------------------------------------------------------------------------
/deps.ts:
--------------------------------------------------------------------------------
 1 | export { parseArgs } from "https://deno.land/std@0.208.0/cli/parse_args.ts";
 2 | export { DelimiterStream } from "https://deno.land/std@0.208.0/streams/mod.ts";
 3 | export { pooledMap } from "https://deno.land/std@0.208.0/async/pool.ts";
 4 | export { retry } from "https://deno.land/std@0.208.0/async/retry.ts";
 5 | export {
 6 |   STATUS_CODE,
 7 |   STATUS_TEXT,
 8 | } from "https://deno.land/std@0.208.0/http/status.ts";
 9 | export { ifNoneMatch } from "https://deno.land/std@0.208.0/http/etag.ts";
10 | export {
11 |   basename,
12 |   extname,
13 |   globToRegExp,
14 |   isGlob,
15 | } from "https://deno.land/std@0.208.0/path/mod.ts";
16 | export {
17 |   endsWith,
18 |   startsWith,
19 | } from "https://deno.land/std@0.208.0/bytes/mod.ts";
20 | export { format as prettyBytes } from "https://deno.land/std@0.208.0/fmt/bytes.ts";
21 | 
22 | export { contentType } from "https://deno.land/std@0.208.0/media_types/mod.ts";
23 | export { encodeHex } from "https://deno.land/std@0.208.0/encoding/hex.ts";
24 | 
25 | export { Article, Client } from "https://deno.land/x/nntp@v0.6.1/mod.ts";
26 | export { YEncDecoderStream } from "https://deno.land/x/yenc@v0.1.0/ystream.ts";
27 | 
28 | export { default as ProgressBar } from "https://deno.land/x/progress@v1.4.0/mod.ts";
29 | 


--------------------------------------------------------------------------------
/combine.ts:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env -S deno run --allow-read
 2 | import { parseArgs } from "./deps.ts";
 3 | 
 4 | import { fetchNZB } from "./util.ts";
 5 | 
 6 | export function help() {
 7 |   return `NZB Combine
 8 |   Combines multiple NZB sources into a target NZB.
 9 | 
10 | INSTALL:
11 |   deno install --allow-read -n nzb-combine https://deno.land/x/nzb/combine.ts
12 | 
13 | USAGE:
14 |   nzb-combine [...options] <target> ...sources
15 | 
16 | OPTIONS:`;
17 | }
18 | 
19 | const parseOptions = {};
20 | 
21 | if (import.meta.main) {
22 |   await combine(Deno.args, Deno.stdout.writable);
23 | }
24 | 
25 | /**
26 |  * Combines multiple NZB sources into a target NZB.
27 |  * @param {string[]} args Argument list.
28 |  * @param {WritableStream} [writable] Writable stream to output to.
29 |  * @returns
30 |  */
31 | export async function combine(
32 |   args = Deno.args,
33 |   output = Deno.stdout.writable,
34 | ) {
35 |   const {
36 |     _: [target, ...sources],
37 |   } = parseArgs(args, parseOptions);
38 | 
39 |   if (!target) {
40 |     console.error("Missing input");
41 |     console.error(help());
42 |     return;
43 |   }
44 | 
45 |   // The first NZB file is used as the result.
46 |   const result = await fetchNZB(target as string);
47 |   for await (const filename of sources) {
48 |     const nzb = await fetchNZB(filename as string);
49 |     // Appends source's files into the target's files.
50 |     result.files.push(...nzb.files);
51 |   }
52 | 
53 |   const writer = output.getWriter();
54 |   await writer.write(new TextEncoder().encode(result.toString()));
55 |   writer.close();
56 | }
57 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 6 |     <meta http-equiv="X-UA-Compatible" content="ie=edge" />
 7 |     <title>NZB Server</title>
 8 |     <base href="{{ base }}/"></base>
 9 |     <link rel="icon" href='data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg"/>' />
10 |   </head>
11 |   <body>
12 |     <main>
13 |       <h1>Index of {{ name | basename }}</h1>
14 | 
15 |       <form>
16 |         <label>
17 |           Filter
18 |           <input name="q" type="search" value="{{ params.q }}" />
19 |         </label>
20 |         <button type="submit">⏎</button>
21 |       </form>
22 | 
23 |       <table cellpadding="6">
24 |         <thead>
25 |           <tr>
26 |             <td></td>
27 |             <th>Name</th>
28 |             <th>Size</th>
29 |             <th>Poster</th>
30 |             <th>Last Modified Date</th>
31 |           </tr>
32 |         </thead>
33 |         <tbody>
34 |           {% for file in files %}
35 |           <tr>
36 |             <td>
37 |               <input type="checkbox" name="files" value="{{ file.name }}" form="bulk" />
38 |             </td>
39 |             <td>
40 |               <a href="{{ file.name }}">{{ file.name }}</a>
41 |             </td>
42 |             <td>
43 |               {{ file.size | prettyBytes }}
44 |             </td>
45 |             <td>
46 |               {{ file.poster }}
47 |             </td>
48 |             <td>
49 |               {{ file.lastModified | UTCString }}
50 |             </td>
51 |           </tr>
52 |           {% endfor %}
53 |         </tbody>
54 |         <tfoot>
55 |           <tr>
56 |             <td>
57 |               <form id="bulk">
58 |                 <button type="submit" formmethod="POST" formaction="?action=extract">Extract</button>
59 |               </form>
60 |             </td>
61 |           </tr>
62 |         </tfoot>
63 |       </table>
64 |     </main>
65 |   </body>
66 | </html>
67 | 


--------------------------------------------------------------------------------
/extract.ts:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env -S deno run --allow-read
 2 | import { globToRegExp, isGlob, parseArgs } from "./deps.ts";
 3 | import { File, NZB } from "./model.ts";
 4 | import { fetchNZB } from "./util.ts";
 5 | 
 6 | export function help() {
 7 |   return `NZB Extract
 8 |   Extract files in an NZB into a new NZB using glob/regex.
 9 | 
10 | INSTALL:
11 |   deno install --allow-read -n nzb-extract https://deno.land/x/nzb/extract.ts
12 | 
13 | USAGE:
14 |   nzb-extract [...options] <input> <glob|regex>
15 | 
16 |   OPTIONS:`;
17 | }
18 | 
19 | const parseOptions = {};
20 | 
21 | if (import.meta.main) {
22 |   await extract(Deno.args, Deno.stdout.writable);
23 | }
24 | 
25 | /**
26 |  * Extracts files from input NZB based on Glob or RegExp.
27 |  *
28 |  * If `out` flag is specified with a path to a file, writes resulting
29 |  * to that file; otherwise, to `stdout`.
30 |  *
31 |  * A second parameter can be used to provide non-string arguments,
32 |  * such as `out` with a `Writer`.
33 |  */
34 | export async function extract(
35 |   args: unknown[] = Deno.args,
36 |   output = Deno.stdout.writable,
37 | ) {
38 |   const {
39 |     _: [input, pattern],
40 |   } = parseArgs(args as string[], parseOptions);
41 | 
42 |   if (!input) {
43 |     console.error("Missing input");
44 |     console.error(help());
45 |     return;
46 |   }
47 | 
48 |   const nzb = typeof input === "string"
49 |     ? await fetchNZB(input)
50 |     : input as unknown as NZB;
51 | 
52 |   let regex: RegExp;
53 | 
54 |   if (isGlob(pattern as string)) {
55 |     regex = globToRegExp(pattern as string);
56 |   } else {
57 |     regex = new RegExp(pattern as string);
58 |   }
59 | 
60 |   // Filters out files that do not matchthe regex.
61 |   filter(nzb.files, regex);
62 | 
63 |   const writer = output.getWriter();
64 |   await writer.write(new TextEncoder().encode(nzb.toString()));
65 |   writer.close();
66 | }
67 | 
68 | /** Filter an array based on a regex inline. */
69 | function filter(files: File[], regex: RegExp) {
70 |   let length = files.length;
71 |   while (length--) {
72 |     if (!regex.test(files[length].name)) {
73 |       files.splice(length, 1);
74 |     }
75 |   }
76 | 
77 |   return files;
78 | }
79 | 


--------------------------------------------------------------------------------
/.github/workflows/x86_64-apple-darwin.yml:
--------------------------------------------------------------------------------
 1 | # This workflow uses actions that are not certified by GitHub.
 2 | # They are provided by a third-party and are governed by
 3 | # separate terms of service, privacy policy, and support
 4 | # documentation.
 5 | 
 6 | # This workflow will install Deno then run Deno lint and test.
 7 | # For more information see: https://github.com/denoland/setup-deno
 8 | 
 9 | name: x86_64-apple-darwin
10 | 
11 | on:
12 |   push:
13 |     branches: [main]
14 |   pull_request:
15 |     branches: [main]
16 | 
17 | permissions:
18 |   contents: read
19 | 
20 | jobs:
21 |   build:
22 |     runs-on: ubuntu-latest
23 |     strategy:
24 |       matrix:
25 |         target: [ x86_64-apple-darwin ]
26 | 
27 |     # Set DENO_DIR to an absolute or relative path on the runner.
28 |     env:
29 |       DENO_DIR: .cache
30 | 
31 |     steps:
32 |       - name: Set git to use LF
33 |         run: |
34 |           git config --global core.autocrlf false
35 |           git config --global core.eol lf
36 | 
37 |       - name: Cache Deno dependencies
38 |         uses: actions/cache@v2
39 |         with:
40 |           path: ${{ env.DENO_DIR }}
41 |           key: ${{ secrets.CACHE_VERSION }}-${{ hashFiles('lock.json') }}
42 | 
43 |       - name: Setup repo
44 |         uses: actions/checkout@v3
45 | 
46 |       - name: Setup Deno
47 |         uses: denoland/setup-deno@v1
48 |         with:
49 |           deno-version: v1.38
50 | 
51 |       # Check if the code is formatted according to Deno's default
52 |       # formatting conventions.
53 |       - name: Verify formatting
54 |         run: deno fmt --check
55 | 
56 |       # Scan the code for syntax errors and style issues.
57 |       - name: Run linter
58 |         run: deno lint
59 | 
60 |       # Run all test files in the repository and collect code coverage. The example
61 |       # runs with all permissions, but it is recommended to run with the minimal permissions your program needs (for example --allow-read).
62 |       # - name: Run tests
63 |       #   run: deno test -A --unstable
64 | 
65 |       - name: Compile
66 |         run: deno task compile:${{ matrix.target }}
67 | 
68 |       - name: Upload artifacts
69 |         uses: actions/upload-artifact@v3
70 |         with:
71 |           name: nzb-${{ matrix.target }}
72 |           path: dist
73 | 


--------------------------------------------------------------------------------
/.github/workflows/aarch64-apple-darwin.yml:
--------------------------------------------------------------------------------
 1 | # This workflow uses actions that are not certified by GitHub.
 2 | # They are provided by a third-party and are governed by
 3 | # separate terms of service, privacy policy, and support
 4 | # documentation.
 5 | 
 6 | # This workflow will install Deno then run Deno lint and test.
 7 | # For more information see: https://github.com/denoland/setup-deno
 8 | 
 9 | name: aarch64-apple-darwin
10 | 
11 | on:
12 |   push:
13 |     branches: [main]
14 |   pull_request:
15 |     branches: [main]
16 | 
17 | permissions:
18 |   contents: read
19 | 
20 | jobs:
21 |   build:
22 |     runs-on: ubuntu-latest
23 |     strategy:
24 |       matrix:
25 |         target: [ aarch64-apple-darwin ]
26 | 
27 |     # Set DENO_DIR to an absolute or relative path on the runner.
28 |     env:
29 |       DENO_DIR: .cache
30 | 
31 |     steps:
32 |       - name: Set git to use LF
33 |         run: |
34 |           git config --global core.autocrlf false
35 |           git config --global core.eol lf
36 | 
37 |       - name: Cache Deno dependencies
38 |         uses: actions/cache@v2
39 |         with:
40 |           path: ${{ env.DENO_DIR }}
41 |           key: ${{ secrets.CACHE_VERSION }}-${{ hashFiles('lock.json') }}
42 | 
43 |       - name: Setup repo
44 |         uses: actions/checkout@v3
45 | 
46 |       - name: Setup Deno
47 |         uses: denoland/setup-deno@v1
48 |         with:
49 |           deno-version: v1.38
50 | 
51 |       # Check if the code is formatted according to Deno's default
52 |       # formatting conventions.
53 |       - name: Verify formatting
54 |         run: deno fmt --check
55 | 
56 |       # Scan the code for syntax errors and style issues.
57 |       - name: Run linter
58 |         run: deno lint
59 | 
60 |       # Run all test files in the repository and collect code coverage. The example
61 |       # runs with all permissions, but it is recommended to run with the minimal permissions your program needs (for example --allow-read).
62 |       # - name: Run tests
63 |       #   run: deno test -A --unstable
64 | 
65 |       - name: Compile
66 |         run: deno task compile:${{ matrix.target }}
67 | 
68 |       - name: Upload artifacts
69 |         uses: actions/upload-artifact@v3
70 |         with:
71 |           name: nzb-${{ matrix.target }}
72 |           path: dist
73 | 


--------------------------------------------------------------------------------
/.github/workflows/x86_64-pc-windows-msvc.yml:
--------------------------------------------------------------------------------
 1 | # This workflow uses actions that are not certified by GitHub.
 2 | # They are provided by a third-party and are governed by
 3 | # separate terms of service, privacy policy, and support
 4 | # documentation.
 5 | 
 6 | # This workflow will install Deno then run Deno lint and test.
 7 | # For more information see: https://github.com/denoland/setup-deno
 8 | 
 9 | name: x86_64-pc-windows-msvc
10 | 
11 | on:
12 |   push:
13 |     branches: [main]
14 |   pull_request:
15 |     branches: [main]
16 | 
17 | permissions:
18 |   contents: read
19 | 
20 | jobs:
21 |   build:
22 |     runs-on: ubuntu-latest
23 |     strategy:
24 |       matrix:
25 |         target: [ x86_64-pc-windows-msvc ]
26 | 
27 |     # Set DENO_DIR to an absolute or relative path on the runner.
28 |     env:
29 |       DENO_DIR: .cache
30 | 
31 |     steps:
32 |       - name: Set git to use LF
33 |         run: |
34 |           git config --global core.autocrlf false
35 |           git config --global core.eol lf
36 | 
37 |       - name: Cache Deno dependencies
38 |         uses: actions/cache@v2
39 |         with:
40 |           path: ${{ env.DENO_DIR }}
41 |           key: ${{ secrets.CACHE_VERSION }}-${{ hashFiles('lock.json') }}
42 | 
43 |       - name: Setup repo
44 |         uses: actions/checkout@v3
45 | 
46 |       - name: Setup Deno
47 |         uses: denoland/setup-deno@v1
48 |         with:
49 |           deno-version: v1.38
50 | 
51 |       # Check if the code is formatted according to Deno's default
52 |       # formatting conventions.
53 |       - name: Verify formatting
54 |         run: deno fmt --check
55 | 
56 |       # Scan the code for syntax errors and style issues.
57 |       - name: Run linter
58 |         run: deno lint
59 | 
60 |       # Run all test files in the repository and collect code coverage. The example
61 |       # runs with all permissions, but it is recommended to run with the minimal permissions your program needs (for example --allow-read).
62 |       # - name: Run tests
63 |       #   run: deno test -A --unstable
64 | 
65 |       - name: Compile
66 |         run: deno task compile:${{ matrix.target }}
67 | 
68 |       - name: Upload artifacts
69 |         uses: actions/upload-artifact@v3
70 |         with:
71 |           name: nzb-${{ matrix.target }}.exe
72 |           path: dist
73 | 


--------------------------------------------------------------------------------
/.github/workflows/x86_64-unknown-linux-gnu.yml:
--------------------------------------------------------------------------------
 1 | # This workflow uses actions that are not certified by GitHub.
 2 | # They are provided by a third-party and are governed by
 3 | # separate terms of service, privacy policy, and support
 4 | # documentation.
 5 | 
 6 | # This workflow will install Deno then run Deno lint and test.
 7 | # For more information see: https://github.com/denoland/setup-deno
 8 | 
 9 | name: x86_64-unknown-linux-gnu
10 | 
11 | on:
12 |   push:
13 |     branches: [main]
14 |   pull_request:
15 |     branches: [main]
16 | 
17 | permissions:
18 |   contents: read
19 | 
20 | jobs:
21 |   build:
22 |     runs-on: ubuntu-latest
23 |     strategy:
24 |       matrix:
25 |         target: [ x86_64-unknown-linux-gnu ]
26 | 
27 |     # Set DENO_DIR to an absolute or relative path on the runner.
28 |     env:
29 |       DENO_DIR: .cache
30 | 
31 |     steps:
32 |       - name: Set git to use LF
33 |         run: |
34 |           git config --global core.autocrlf false
35 |           git config --global core.eol lf
36 | 
37 |       - name: Cache Deno dependencies
38 |         uses: actions/cache@v2
39 |         with:
40 |           path: ${{ env.DENO_DIR }}
41 |           key: ${{ secrets.CACHE_VERSION }}-${{ hashFiles('lock.json') }}
42 | 
43 |       - name: Setup repo
44 |         uses: actions/checkout@v3
45 | 
46 |       - name: Setup Deno
47 |         uses: denoland/setup-deno@v1
48 |         with:
49 |           deno-version: v1.38
50 | 
51 |       # Check if the code is formatted according to Deno's default
52 |       # formatting conventions.
53 |       - name: Verify formatting
54 |         run: deno fmt --check
55 | 
56 |       # Scan the code for syntax errors and style issues.
57 |       - name: Run linter
58 |         run: deno lint
59 | 
60 |       # Run all test files in the repository and collect code coverage. The example
61 |       # runs with all permissions, but it is recommended to run with the minimal permissions your program needs (for example --allow-read).
62 |       # - name: Run tests
63 |       #   run: deno test -A --unstable
64 | 
65 |       - name: Compile
66 |         run: deno task compile:${{ matrix.target }}
67 | 
68 |       - name: Upload artifacts
69 |         uses: actions/upload-artifact@v3
70 |         with:
71 |           name: nzb-${{ matrix.target }}
72 |           path: dist
73 | 


--------------------------------------------------------------------------------
/mod.ts:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env -S deno run --allow-net --allow-env --allow-read --allow-write
 2 | import { check } from "./check.ts";
 3 | import { combine } from "./combine.ts";
 4 | import { extract } from "./extract.ts";
 5 | import { get } from "./get.ts";
 6 | import { mirror } from "./mirror.ts";
 7 | import { search } from "./search.ts";
 8 | import { serve } from "./serve.ts";
 9 | 
10 | export function help() {
11 |   return `NZB Toolkit
12 |   Various tools for handling NZB files
13 | 
14 | INSTALL:
15 |   deno install --allow-net --allow-env --allow-read --allow-write -n nzb https://deno.land/x/nzb/mod.ts
16 | 
17 | USAGE:
18 |   nzb <command> <input> [...options]
19 | 
20 | COMMANDS:
21 |   check [--method] [...options] <input>
22 |   combine [...options] <target> ...sources
23 |   extract [...options] <input> <glob|regex>
24 |   get [...options] <input> <filename>
25 |   mirror [...options] <input>
26 |   search [...options] <input>
27 |   serve [...options] <input>
28 | 
29 | OPTIONS:
30 |   --address, -addr <address> IPaddress:Port or :Port to bind server to (default "127.0.0.1:8000")
31 |   --template, -t <template> Path to HTML template to use (default "./index.html")
32 |   --hostname, -h <hostname> The hostname of the NNTP server.
33 |   --port, -P <port> The port of the NNTP server.
34 |   --ssl, -S Whether to use SSL.
35 |   --username, -u <username> The username to authenticate with.
36 |   --password, -p <password> The password to authenticate with.
37 |   --connections, -n <connections> The number of connections to use.
38 |   --connect-retries, -r <connect-retries> The number of retries to connect.
39 |   --reconnect-delay, -d <reconnect-delay> The delay between reconnects.
40 |   --request-retries, -R <request-retries> The number of retries to request.
41 |   --post-retry-delay, -D <post-retry-delay> The delay between retries.
42 |   --comment, -t <comment> The comment to use.
43 |   --comment2, -T <comment2> The second comment to use.
44 |   --subject, -s <subject> The subject to use.
45 |   --from, -f <from> The from address to use.
46 |   --groups, -g <groups> The groups to post to.
47 |   --date, -D <date> The date to use.
48 |   --message-id, -m <message-id> The message-id to use.
49 |   --out, -o <out> The output file.
50 |   --progress, -p Whether to show progress.`;
51 | }
52 | 
53 | const exports = {
54 |   check,
55 |   combine,
56 |   extract,
57 |   get,
58 |   mirror,
59 |   search,
60 |   serve,
61 | };
62 | 
63 | if (import.meta.main) {
64 |   const [command, ...args] = Deno.args;
65 | 
66 |   if (!command || command === "help") {
67 |     console.error(help());
68 |   } else {
69 |     exports[command as keyof typeof exports](args);
70 |   }
71 | }
72 | 
73 | export default exports;
74 | 


--------------------------------------------------------------------------------
/check.ts:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env -S deno run --allow-read --allow-env --allow-net
  2 | import { Client, parseArgs } from "./deps.ts";
  3 | import { File, NZB } from "./model.ts";
  4 | import { fetchNZB } from "./util.ts";
  5 | 
  6 | export function help() {
  7 |   return `NZB Check
  8 |   Check files in an NZB for missing articles
  9 | 
 10 | INSTALL:
 11 |   deno install --allow-read --allow-env --allow-net -n nzb-check https://deno.land/x/nzb/check.ts
 12 | 
 13 | USAGE:
 14 |   nzb-check [...options] <input> [filename]
 15 | 
 16 |   OPTIONS:
 17 |     --hostname, -h <hostname> The hostname of the NNTP server.
 18 |     --port, -P <port> The port of the NNTP server.
 19 |     --ssl, -S Whether to use SSL.
 20 |     --username, -u <username> Username to authenticate with the NNTP server.
 21 |     --password, -p <password> Password to authenticate with the NNTP server.
 22 |     --method <method> The method to use to check articles. (one of "STAT", "HEAD", "BODY" or "ARTICLE", default "STAT")`;
 23 | }
 24 | 
 25 | const parseOptions = {
 26 |   string: [
 27 |     "hostname",
 28 |     "port",
 29 |     "username",
 30 |     "password",
 31 |     "method",
 32 |   ],
 33 |   boolean: [
 34 |     "ssl",
 35 |   ],
 36 |   alias: {
 37 |     "hostname": ["host", "h"],
 38 |     "port": "P",
 39 |     "ssl": "S",
 40 |     "username": ["user", "u"],
 41 |     "password": ["pass", "p"],
 42 |   },
 43 |   default: {
 44 |     hostname: Deno.env.get("NNTP_HOSTNAME"),
 45 |     port: Deno.env.get("NNTP_PORT"),
 46 |     username: Deno.env.get("NNTP_USER"),
 47 |     password: Deno.env.get("NNTP_PASS"),
 48 |     ssl: Deno.env.get("NNTP_SSL") === "true",
 49 |     method: "STAT",
 50 |   },
 51 | };
 52 | 
 53 | if (import.meta.main) {
 54 |   check(Deno.args);
 55 | }
 56 | 
 57 | export async function check(args: unknown[] = Deno.args) {
 58 |   const parsedArgs = parseArgs(args as string[], parseOptions);
 59 |   const {
 60 |     _: [input, filename],
 61 |     hostname,
 62 |     port,
 63 |     ssl,
 64 |     username,
 65 |     password,
 66 |     method = "STAT",
 67 |   } = parsedArgs;
 68 | 
 69 |   if (!input) {
 70 |     console.error("Missing input");
 71 |     console.error(help());
 72 |     return;
 73 |   }
 74 | 
 75 |   const nzb = typeof input === "string"
 76 |     ? await fetchNZB(input)
 77 |     : input as unknown as NZB;
 78 |   const file = typeof filename === "string"
 79 |     ? nzb.file(filename)
 80 |     : filename as unknown as File;
 81 | 
 82 |   const client = await Client.connect({
 83 |     hostname,
 84 |     port: Number(port),
 85 |     ssl: !!ssl,
 86 |   });
 87 | 
 88 |   if (username) {
 89 |     await client.authinfo(username, password);
 90 |   }
 91 | 
 92 |   const files = file ? [file] : nzb.files;
 93 | 
 94 |   for await (const file of files) {
 95 |     console.time(`Checking ${file.name}`);
 96 |     for await (const segment of file.segments) {
 97 |       console.time(`Checking article ${segment.id}`);
 98 |       const response = await client.request(method!, segment.id);
 99 |       if (response.status === 430) {
100 |         console.log(`Article ${segment.id} of file ${file.name} is missing`);
101 |       }
102 |       console.timeEnd(`Checking article ${segment.id}`);
103 |     }
104 |     console.timeEnd(`Checking ${file.name}`);
105 |   }
106 | }
107 | 


--------------------------------------------------------------------------------
/mirrorArticle.ts:
--------------------------------------------------------------------------------
  1 | import { Article, Client, parseArgs, retry } from "./deps.ts";
  2 | 
  3 | export function help() {
  4 |   return `NZB Mirror Article
  5 |   Mirrors an article to another.`;
  6 | }
  7 | 
  8 | const parseOptions = {
  9 |   string: [
 10 |     "hostname",
 11 |     "username",
 12 |     "password",
 13 |   ],
 14 |   boolean: [
 15 |     "ssl",
 16 |     "join-group",
 17 |     "progress",
 18 |   ],
 19 |   default: {
 20 |     hostname: Deno.env.get("NNTP_HOSTNAME"),
 21 |     port: Number(Deno.env.get("NNTP_PORT")),
 22 |     ssl: Deno.env.get("NNTP_SSL") === "true",
 23 |     username: Deno.env.get("NNTP_USER"),
 24 |     password: Deno.env.get("NNTP_PASS"),
 25 |     "connect-retries": 1,
 26 |     "reconnect-delay": 15 * 1000,
 27 |     "request-retries": 5,
 28 |     "post-retry-delay": 0,
 29 |     "join-group": false,
 30 |     progress: false,
 31 |   },
 32 | };
 33 | 
 34 | export async function mirrorArticle(
 35 |   args: unknown[] = Deno.args,
 36 |   dst: Article = new Article(),
 37 | ) {
 38 |   const parsedArgs = parseArgs(args as string[], parseOptions);
 39 |   const {
 40 |     _: [input],
 41 |     ...options
 42 |   } = parsedArgs;
 43 | 
 44 |   if (!input) {
 45 |     console.error("Missing input");
 46 |     console.error(help());
 47 |     return;
 48 |   }
 49 | 
 50 |   const src = typeof input === "string"
 51 |     ? new Article(input)
 52 |     : input as unknown as Article;
 53 | 
 54 |   const originalMessageId = src.headers.get("message-id")!;
 55 |   const messageId = dst.headers.get("message-id") ||
 56 |     `<${crypto.randomUUID()}@nntp>`;
 57 | 
 58 |   const client = await setup(options);
 59 | 
 60 |   // Some providers require choosing group before accessing article.
 61 |   if (options["join-group"]) {
 62 |     await client.group(src.headers.get("newsgroups")!.split(",")[0]);
 63 |   }
 64 | 
 65 |   let response = await client.article(originalMessageId);
 66 |   const { status, headers } = response;
 67 | 
 68 |   if (status === 430) return null;
 69 | 
 70 |   // Reads the body to completion so we can reuse the connection,
 71 |   // then converts it to a new ReadableStream.
 72 |   const body = (await response.blob()).stream();
 73 | 
 74 |   setDefaults(dst.headers, {
 75 |     date: new Date().toUTCString(),
 76 |     from: headers.get("from")!,
 77 |     "message-id": messageId,
 78 |     newsgroups: headers.get("newsgroups")!,
 79 |     subject: headers.get("subject")!,
 80 |   });
 81 | 
 82 |   dst.body = body;
 83 | 
 84 |   response = await retry(
 85 |     async () => {
 86 |       const response = await client.post(dst);
 87 |       return response;
 88 |     },
 89 |     {
 90 |       multiplier: 1,
 91 |       jitter: 0,
 92 |       minTimeout: Number(options["post-retry-delay"] || 0),
 93 |       maxAttempts: Number(options["request-retries"] || 5),
 94 |     },
 95 |   );
 96 | 
 97 |   client.close();
 98 | 
 99 |   if (response.status === 240) {
100 |     return dst;
101 |   }
102 | 
103 |   console.error(`${response.status} ${response.statusText}`);
104 | 
105 |   return null;
106 | }
107 | 
108 | async function setup(options: Record<string, unknown> = {}) {
109 |   const { hostname, port, ssl, username, password } = options;
110 | 
111 |   return await retry(
112 |     async () => {
113 |       const client = await Client.connect({
114 |         hostname: `${hostname}`,
115 |         port: Number(port),
116 |         ssl: !!ssl,
117 |         logLevel: "WARNING",
118 |       });
119 | 
120 |       if (username) {
121 |         await client.authinfo(`${username}`, `${password}`);
122 |       }
123 | 
124 |       return client;
125 |     },
126 |     {
127 |       multiplier: 1,
128 |       jitter: 0,
129 |       maxAttempts: Number(options["connect-retries"] || 1),
130 |       minTimeout: Number(options["reconnect-delay"] || 15 * 1000),
131 |     },
132 |   );
133 | }
134 | 
135 | function setDefaults(headers: Headers, defaults: Record<string, string> = {}) {
136 |   Object.entries(defaults)
137 |     .filter(([_k, v]) => v)
138 |     .forEach(([k, v]) => {
139 |       const header = headers.get(k);
140 |       if (!header || header === "undefined") {
141 |         headers.set(k, v);
142 |       }
143 |     });
144 | }
145 | 


--------------------------------------------------------------------------------
/util.ts:
--------------------------------------------------------------------------------
  1 | import { extname, prettyBytes, ProgressBar } from "./deps.ts";
  2 | import { NZB } from "./model.ts";
  3 | 
  4 | /**
  5 |  * Fetches a NZB file from the given URL.
  6 |  */
  7 | export async function fetchNZB(input: string) {
  8 |   const url = new URL(input, import.meta.url).href;
  9 |   const file: Response = await fetch(url);
 10 |   let body = file.body!;
 11 |   if (extname(url) === ".gz") {
 12 |     body = body.pipeThrough(new DecompressionStream("gzip"));
 13 |   }
 14 | 
 15 |   return NZB.from(
 16 |     body,
 17 |     input,
 18 |   );
 19 | }
 20 | 
 21 | /**
 22 |  * Pretifies number of seconds into "dd:hh:mm:ss".
 23 |  */
 24 | export function prettySeconds(seconds: number): string {
 25 |   let result = new Date(1000 * seconds).toISOString().substring(11, 19);
 26 |   // Prefixes with number of days if any.
 27 |   result = parseInt(`${seconds / 86400}`) + `:${result}`;
 28 |   // result = result.replace(/00/g, "0");
 29 |   result = result.replace(
 30 |     /(\d+:)?(\d+:)?(\d+:)?(\d+)?/,
 31 |     (_, days, hours, minutes, seconds) => {
 32 |       let result = seconds + "s";
 33 |       if (minutes) result = minutes.replace(":", "m:") + result;
 34 |       if (hours) result = hours.replace(":", "h:") + result;
 35 |       if (days) result = days.replace(":", "d:") + result;
 36 |       return result;
 37 |     },
 38 |   );
 39 |   result = result.replace(/^[0(d|h|m|s):]+/, "");
 40 |   result = result.replace(/00/g, "0");
 41 | 
 42 |   return result;
 43 | }
 44 | 
 45 | const SUBJECT_REGEX =
 46 |   /"(?<name>[^"]+)"(?: yEnc)?(?: \((?<partnum>[\d]+)\/(?<numparts>[\d]+)\))?(?: yEnc)?[^\d]?(?<size>[\d]+)?/;
 47 | 
 48 | /**
 49 |  * Parses a subject line of a yEnc article to file name and size.
 50 |  *
 51 |  * Standard single-part yEncoded binaries require no special conventions for
 52 |  * the subject line.  It is recommended, however, that yEncoded binaries be
 53 |  * specifically identified as such, until the yEncode encoding format becomes
 54 |  * more widely implemented.
 55 |  *
 56 |  * The suggested format for subject lines for single-part binaries is:
 57 |  *
 58 |  * [Comment1] "filename" 12345 yEnc bytes [Comment2]
 59 |  *
 60 |  * [Comment1] and [Comment2] are optional.  The filename should always be
 61 |  * enclosed in quotes; this allows for easy detection, even when the filename
 62 |  * includes spaces or other special characters.  The word "yEnc" should be
 63 |  * placed in between the file size and the word "bytes".
 64 |  * > (1.2) see additional experience information
 65 |  * > Placing the word "yEnc" between filename+bytes or bytes+comment2
 66 |  * > is acceptable.
 67 |  *
 68 |  * Multi-part archives should always be identified as such.  As with
 69 |  * single-part binaries, they should also be identified as yEncoded until
 70 |  * yEncoding becomes more mainstream.
 71 |  *
 72 |  * The (strongly) recommended format for subject lines for multi-part binaries
 73 |  * is:
 74 |  *
 75 |  * [Comment1] "filename" yEnc (partnum/numparts) [size] [Comment2]
 76 |  *
 77 |  * Again, [Comment1] and [Comment2] are optional.  The [size] value is also
 78 |  * optional here.  The filename must be included, in quotes.  The keyword
 79 |  * "yEnc" is mandatory, and must appear between the filename and the size (or
 80 |  * Comment2, if size is omitted).  Future revisions of the draft may specify
 81 |  * additional information may be inserted between the "yEnc" keyword and the
 82 |  * opening parenthesis of the part number.
 83 |  * > (1.2) see additional experience information
 84 |  * > Placing the word "yEnc" between (#/#)+size or size+comment2
 85 |  * > is acceptable.
 86 |  *
 87 |  * ## Examples
 88 |  *
 89 |  * ```ts
 90 |  * yEncParse(`reftestnzb 100MB f4d76efc6789 [01/16] - "SomeTestfile-100MB.part1.rar" yEnc (1/22) 15728640`);
 91 |  * { name: "SomeTestfile-100MB.part1.rar", size: 15728640, partnum: 1, numparts: 22 }
 92 |  * ```
 93 |  *
 94 |  * @param {string} subject The subject line of the article.
 95 |  * @returns {object} An object with the parsed values.
 96 |  */
 97 | export function yEncParse(
 98 |   subject: string,
 99 | ): { name?: string; size?: number; partnum?: number; numparts?: number } {
100 |   const { groups = {} } = subject.match(SUBJECT_REGEX) || {};
101 |   return groups;
102 | }
103 | 
104 | /**
105 |  * Custom Progress with prettified values.
106 |  */
107 | export class Progress extends ProgressBar {
108 |   #start;
109 | 
110 |   constructor(options = {}) {
111 |     super(options);
112 |     this.#start = Date.now();
113 |   }
114 | 
115 |   render(completed: number, options: Record<string, string | number> = {}) {
116 |     const total = (options.total ?? this.total ?? 100) as number;
117 |     const elapsed = Date.now() - this.#start;
118 | 
119 |     const display = this.display;
120 |     // Overrides the progress bar display to pretify numbers.
121 |     this.display = display
122 |       .replace(":completed", prettyBytes(Math.min(completed, total)))
123 |       .replace(":total", prettyBytes(total))
124 |       // Ensures percentages is not over 100%.
125 |       .replace(
126 |         ":percent",
127 |         Math.min((completed / total) * 100, 100).toFixed(2) + "%",
128 |       )
129 |       // Displays rate.
130 |       .replace(
131 |         ":rate",
132 |         prettyBytes((completed / elapsed) * 1000),
133 |       )
134 |       // Pretifies elapsed time
135 |       .replace(
136 |         ":time",
137 |         prettySeconds(elapsed / 1000),
138 |       )
139 |       // Pretifies ETA time.
140 |       .replace(
141 |         ":eta",
142 |         completed == 0
143 |           ? "-"
144 |           : (completed >= total
145 |             ? "0s"
146 |             : prettySeconds((total / completed - 1) * elapsed / 1000)),
147 |       );
148 | 
149 |     super.render(completed, options);
150 |     this.display = display;
151 |   }
152 | }
153 | 


--------------------------------------------------------------------------------
/search.ts:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env -S deno run --allow-env --allow-net
  2 | import { Client, DelimiterStream, parseArgs } from "./deps.ts";
  3 | import { File, NZB, Segment } from "./model.ts";
  4 | import { yEncParse } from "./util.ts";
  5 | 
  6 | export function help() {
  7 |   return `NZB Search
  8 |   Search files and stores results into an NZB file.
  9 | 
 10 | INSTALL:
 11 |   deno install --allow-env --allow-net -n nzb-search https://deno.land/x/nzb/search.ts
 12 | 
 13 | USAGE:
 14 |   nzb-search [...options] <query>
 15 | 
 16 |   OPTIONS:
 17 |     --group <group> Group name to search from
 18 |     --range <start>-[end] Range of article numbers to search within.
 19 |     --meta <name>=<value> Meta data to add in the resulting NZB, such as password.
 20 | 
 21 | PERMISSIONS:
 22 |   --allow-env: to read environment variables for NTTP providers.
 23 |   --allow-net: to connect to NNTP provider.`;
 24 | }
 25 | 
 26 | const encoder = new TextEncoder();
 27 | const CRLF = encoder.encode("\r\n");
 28 | 
 29 | const parseOptions = {
 30 |   string: [
 31 |     "hostname",
 32 |     "username",
 33 |     "password",
 34 |     "group",
 35 |     "range",
 36 |   ],
 37 |   boolean: [
 38 |     "ssl",
 39 |   ],
 40 |   collect: ["meta"],
 41 |   default: {
 42 |     hostname: Deno.env.get("NNTP_HOSTNAME"),
 43 |     port: Number(Deno.env.get("NNTP_PORT")),
 44 |     username: Deno.env.get("NNTP_USER"),
 45 |     password: Deno.env.get("NNTP_PASS"),
 46 |     ssl: Deno.env.get("NNTP_SSL") === "true",
 47 |     group: "",
 48 |     range: "",
 49 |   },
 50 | };
 51 | 
 52 | if (import.meta.main) {
 53 |   search(Deno.args, Deno.stdout.writable);
 54 | }
 55 | 
 56 | /**
 57 |  * Searches files matching query and stores into a NZB file.
 58 |  */
 59 | export async function search(
 60 |   args: unknown[] = Deno.args,
 61 |   output = Deno.stdout.writable,
 62 | ) {
 63 |   const parsedArgs = parseArgs(args as string[], parseOptions);
 64 |   let {
 65 |     _: [query],
 66 |     hostname,
 67 |     port,
 68 |     ssl,
 69 |     username,
 70 |     password,
 71 |     group,
 72 |     range,
 73 |     meta,
 74 |   } = parsedArgs;
 75 | 
 76 |   if (!query) {
 77 |     console.error("Missing query");
 78 |     console.error(help());
 79 |     return;
 80 |   }
 81 | 
 82 |   const client = await Client.connect({
 83 |     hostname: `${hostname}`,
 84 |     port: Number(port),
 85 |     ssl: !!ssl,
 86 |     logLevel: "WARNING",
 87 |   });
 88 | 
 89 |   if (username) {
 90 |     await client.authinfo(`${username}`, `${password}`);
 91 |   }
 92 | 
 93 |   let response;
 94 |   response = await client.capabilities();
 95 |   const capabilities = await response.text();
 96 | 
 97 |   // Selects group as active
 98 |   response = await client.group(group as string);
 99 |   if (response.status !== 211) {
100 |     console.error("Invalid group");
101 |     return;
102 |   }
103 | 
104 |   const [_total, first, last] = response.statusText.split(" ");
105 |   if (!range) {
106 |     range = `${first}-${last}`;
107 |   }
108 | 
109 |   // Uses second-form of OVER/XOVER command to retrieve all headers
110 |   if (capabilities.includes("XOVER")) { // legacy server.
111 |     response = await client.request("XOVER", range as string);
112 |   } else {
113 |     response = await client.over(range as string);
114 |   }
115 | 
116 |   if (response.status !== 224) {
117 |     console.error("No articles found");
118 |     return;
119 |   }
120 | 
121 |   // Starts with an emtpy NZB file.
122 |   const nzb = new NZB();
123 |   // Sets meta data in the head.
124 |   (meta as string[]).forEach((element: string) => {
125 |     const [key, value] = element.split("=");
126 |     nzb.head[key] = value;
127 |   });
128 | 
129 |   const files = nzb.files;
130 |   let lastArticleNumber: string;
131 | 
132 |   // TODO: parallelize
133 |   return response.body!
134 |     // `OVER` command returns a stream of articles in each lines.
135 |     .pipeThrough(new DelimiterStream(CRLF))
136 |     .pipeThrough(new TextDecoderStream())
137 |     .pipeThrough(
138 |       new TransformStream({
139 |         start() {
140 |           Deno.addSignalListener("SIGINT", () => {
141 |             console.log("stopped at", lastArticleNumber);
142 |             Deno.exit(0);
143 |           });
144 |         },
145 |         transform(articleOverview: string) {
146 |           // Each lines contains 8 mandatory fields, separated by TAB.
147 |           const [
148 |             articleNumber,
149 |             subject,
150 |             poster,
151 |             date,
152 |             id,
153 |             _references,
154 |             bytes,
155 |             _lines,
156 |           ] = articleOverview.split("\t");
157 | 
158 |           if (subject.includes(query as string)) {
159 |             const { name, size, partnum, numparts } = yEncParse(subject);
160 |             let file = files.find((file) => file.name === name);
161 |             if (!file) {
162 |               file = {
163 |                 poster,
164 |                 subject,
165 |                 groups: [group!],
166 |                 lastModified: new Date(date).getTime(),
167 |                 name,
168 |                 size,
169 |                 segments: new Array(Number(numparts)),
170 |               } as File;
171 |               files.push(file);
172 |             }
173 | 
174 |             const number = Number(partnum);
175 | 
176 |             const segment: Segment = {
177 |               id: id.replace("<", "").replace(">", ""),
178 |               number,
179 |               size: Number(bytes),
180 |             };
181 | 
182 |             file.segments[number - 1] = segment;
183 |           }
184 | 
185 |           // Keeps this reference so we can resume in case of interuption.
186 |           lastArticleNumber = articleNumber;
187 |         },
188 |         flush(controller) {
189 |           controller.enqueue(nzb.toString());
190 |         },
191 |       }),
192 |     )
193 |     .pipeThrough(new TextEncoderStream())
194 |     .pipeTo(output, { preventClose: true });
195 | }
196 | 


--------------------------------------------------------------------------------
/index.xsl:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  3 | 
  4 |   <!-- Set the character set -->
  5 |   <xsl:output method="html" encoding="utf-8" indent="yes" media-type="text/html; charset=utf-8" />
  6 | 
  7 |   <xsl:template match="/*[local-name() = 'nzb']">
  8 |     <xsl:variable name="title" select="*/*[local-name() = 'meta' and @*[local-name() = 'type' and . = 'title']]" />
  9 | 
 10 |     <!-- Set the DOCTYPE targeting HTML5 -->
 11 |     <xsl:text disable-output-escaping='yes'>&lt;!DOCTYPE html></xsl:text>
 12 | 
 13 |     <html>
 14 |       <!-- Set default language to En. -->
 15 |       <xsl:attribute name="lang">en</xsl:attribute>
 16 |       <head>
 17 |         <title><xsl:value-of select="$title" /></title>
 18 |         <meta charset="UTF-8" />
 19 |         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 20 |         <link rel="icon" href='data:image/svg+xml,&lt;svg xmlns="http://www.w3.org/2000/svg"/>'></link>
 21 | 
 22 |         <script>
 23 |           window.addEventListener("load", function() {
 24 |             document.querySelector(`[name="q"]`).value = new URLSearchParams(location.search).get('q');
 25 |           });
 26 |         </script>
 27 |       </head>
 28 | 
 29 |       <body>
 30 |         <main>
 31 |           <h1>Index of <xsl:value-of select="$title" /></h1>
 32 | 
 33 |           <form>
 34 |             <label>
 35 |               Filter
 36 |               <input name="q" type="search" value="" />
 37 |             </label>
 38 |             <button type="submit">⏎</button>
 39 |           </form>
 40 | 
 41 |           <table cellpadding="6">
 42 | 
 43 |             <thead>
 44 |               <tr>
 45 |                 <td></td>
 46 |                 <th>Name</th>
 47 |                 <th>Size</th>
 48 |                 <th>Poster</th>
 49 |                 <th>Last Modified Date</th>
 50 |               </tr>
 51 |             </thead>
 52 | 
 53 |             <tbody>
 54 |               <xsl:apply-templates select="*[local-name() = 'file']" />
 55 |             </tbody>
 56 | 
 57 |             <tfoot>
 58 |               <tr>
 59 |                 <td>
 60 |                   <form id="bulk">
 61 |                     <button type="submit" formmethod="POST" formaction="?action=extract">Extract</button>
 62 |                   </form>
 63 |                 </td>
 64 |               </tr>
 65 |             </tfoot>
 66 | 
 67 |           </table>
 68 |         </main>
 69 |       </body>
 70 |     </html>
 71 | 
 72 |   </xsl:template>
 73 | 
 74 |   <xsl:template match="*[local-name() = 'file']">
 75 |     <xsl:variable name="subject" select="@*[local-name() = 'subject']" />
 76 |     <xsl:variable name="name" select="substring-before(substring-after($subject, '&quot;'), '&quot;')" />
 77 |     <xsl:variable name="bytes" select="sum(.//*[local-name() = 'segment']/@*[local-name() = 'bytes'])" />
 78 | 
 79 |     <tr>
 80 |       <td>
 81 |         <input type="checkbox" name="files" value="$name" form="bulk" />
 82 |       </td>
 83 |       <td>
 84 |         <a href="{$name}"><xsl:value-of select="$name" /></a>
 85 |       </td>
 86 |       <td>
 87 |         <xsl:call-template name="prettyBytes">
 88 |           <xsl:with-param name="bytes" select="$bytes" />
 89 |         </xsl:call-template>
 90 |       </td>
 91 |       <td>
 92 |         <xsl:value-of select="@*[local-name() = 'poster']" disable-output-escaping="yes" />
 93 |       </td>
 94 |       <td>
 95 |         <xsl:call-template name="ISOString">
 96 |           <xsl:with-param name="unixTime" select="@*[local-name() = 'date']" />
 97 |         </xsl:call-template>
 98 |       </td>
 99 |     </tr>
100 |   </xsl:template>
101 | 
102 |   <xsl:template name="prettyBytes">
103 |     <xsl:param name="bytes" />
104 |     <xsl:choose>
105 |       <xsl:when test="round($bytes div 1024) &lt; 1">
106 |         <xsl:value-of select="$bytes" /> B
107 |       </xsl:when>
108 |       <xsl:when test="round($bytes div 1048576) &lt; 1">
109 |         <xsl:value-of select="format-number(($bytes div 1024), '0.0')" /> KB
110 |       </xsl:when>
111 |       <xsl:when test="round($bytes div 1073741824) &lt; 1">
112 |         <xsl:value-of select="format-number(($bytes div 1048576), '0.0')" /> MB
113 |       </xsl:when>
114 |       <xsl:otherwise>
115 |         <xsl:value-of select="format-number(($bytes div 1073741824), '0.00')" /> GB
116 |       </xsl:otherwise>
117 |     </xsl:choose>
118 |   </xsl:template>
119 | 
120 |   <xsl:template name="ISOString">
121 |     <xsl:param name="unixTime" />
122 | 
123 |     <xsl:variable name="JDN" select="floor($unixTime div 86400) + 2440588" />
124 |     <xsl:variable name="secs" select="$unixTime mod 86400" />
125 | 
126 |     <xsl:variable name="f" select="$JDN + 1401 + floor((floor((4 * $JDN + 274277) div 146097) * 3) div 4) - 38"/>
127 |     <xsl:variable name="e" select="4*$f + 3"/>
128 |     <xsl:variable name="g" select="floor(($e mod 1461) div 4)"/>
129 |     <xsl:variable name="h" select="5*$g + 2"/>
130 | 
131 |     <xsl:variable name="d" select="floor(($h mod 153) div 5 ) + 1"/>
132 |     <xsl:variable name="m" select="(floor($h div 153) + 2) mod 12 + 1"/>
133 |     <xsl:variable name="y" select="floor($e div 1461) - 4716 + floor((14 - $m) div 12)"/>
134 | 
135 |     <xsl:variable name="H" select="floor($secs div 3600)"/>
136 |     <xsl:variable name="M" select="floor($secs mod 3600 div 60)"/>
137 |     <xsl:variable name="S" select="$secs mod 60"/>
138 | 
139 |     <xsl:value-of select="$y"/>
140 |     <xsl:text>-</xsl:text>
141 |     <xsl:value-of select="format-number($m, '00')"/>
142 |     <xsl:text>-</xsl:text>
143 |     <xsl:value-of select="format-number($d, '00')"/>
144 |     <xsl:text>T</xsl:text>
145 |     <xsl:value-of select="format-number($H, '00')"/>
146 |     <xsl:text>:</xsl:text>
147 |     <xsl:value-of select="format-number($M, '00')"/>
148 |     <xsl:text>:</xsl:text>
149 |     <xsl:value-of select="format-number($S, '00')"/>
150 |   </xsl:template>
151 | </xsl:stylesheet>
152 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # nzb
  2 | 
  3 | Collection of tools handling NZB files
  4 | 
  5 | ## Usage
  6 | 
  7 | Each commands can be run under Deno with `deno run -A mod.ts command args`, or
  8 | using the pre-built binaries for each platforms in Releases.
  9 | 
 10 | ## Commands
 11 | 
 12 | - [x] `check`: Checks if a NZB file is fetchable.
 13 | - [x] `combine`: Combines multiple NZB files into one.
 14 | - [x] `extract`: Extracts files in a NZB file into new NZB files.
 15 | - [x] `get`: Fetches data specified in a NZB file.
 16 | - [x] `mirror`: Mirrors articles in a NZB file with new information.
 17 | - [x] `search`: Searches files into a NZB file.
 18 | - [x] `serve`: Serves a NZB file as an index webpage.
 19 | 
 20 | ## `check`
 21 | 
 22 | Checks if all articles in the NZB still exist. By default, the check is done
 23 | using `STAT` method, which is faster but not as reliable as `HEAD` method. Use
 24 | `--method` flag to specify the method to use.
 25 | 
 26 | ```shell
 27 | nzb check source.nzb --method=HEAD
 28 | ```
 29 | 
 30 | ## `combine`
 31 | 
 32 | Combines one or more NZBs into one. The resulting NZB is written to `stdout` or
 33 | a file specifiied in `--out` flag.
 34 | 
 35 | ```shell
 36 | nzb combine source.S01D* > S01.nzb
 37 | nzb combine source.S01D* --out S01.nzb
 38 | ```
 39 | 
 40 | ## `extract`
 41 | 
 42 | Extracts only certain files in the input NZB based on a Glob or RegExp. The
 43 | resulting NZB is written to `stdout` or a file specifiied in `--out` flag.
 44 | 
 45 | ```shell
 46 | nzb extract source.nzb "*.part*.rar" > parts.nzb
 47 | nzb extract source.nzb ".*\.part[\d]+\.rar" --out parts.nzb
 48 | ```
 49 | 
 50 | ## `get`
 51 | 
 52 | Fetches segments of specific file in the NZB, yEnc decodes and combines them
 53 | back to original file, and writes them to `stdout` or a file specifiied in
 54 | `--out` flag.
 55 | 
 56 | ```shell
 57 | nzb get source.nzb test_file.bin > test.bin
 58 | nzb get source.nzb test_file.bin --out test.bin
 59 | ```
 60 | 
 61 | `get` also supports range request with `--start` and/or `--end` flags.
 62 | 
 63 | ## `mirror`
 64 | 
 65 | Mirrors the articles in the input NZB, either to the same group or new ones, and
 66 | outputs the resulting NZB to stdout or a specified output file.
 67 | 
 68 | ```shell
 69 | nzb mirror \
 70 |   --hostname="localhost" \
 71 |   --port=119 \
 72 |   --username="" \
 73 |   --password="" \
 74 |   --connections=3 \ # Number of connections
 75 |   --connect-retries=1 \ # Number of times to retry to connect.
 76 |   --reconnect-delay=15*1000 \ # Microseconds to wait before reconnecting.
 77 |   --request-retries=5 \ # Number of times to retry to post if failed.
 78 |   --post-retry-delay=0 \ # Microseconds to wait before retrying posting.
 79 |   --comment="" \ # Comment to insert before post subject
 80 |   --comment2="" \ # Comment to append after post subject
 81 |   --subject="" \ # Custom subject to use for posts. See below for available placeholders.
 82 |   --from="poster@example.com" \ # Name of poster
 83 |   --groups="alt.binaries.test" \ # Groups to post new articles to, separated by commas.
 84 |   --date \ # Specific date for each article. Can take a "now" to refer script's start time.
 85 |   --message-id="" \ # Format of generated Message-ID. See below for available placeholders.
 86 |   source.nzb \ # Source file to mirror from.
 87 |   --out=mirror.nzb # Path to a file to write new NZB to.
 88 | ```
 89 | 
 90 | If `--out` is supplied, will write NZB to this file. Can be '-' which writes the
 91 | NZB to `stdout`. The following placeholders are also supported (see below for
 92 | details):
 93 | 
 94 | ```
 95 | {files}
 96 | {filename}
 97 | {fnamebase}
 98 | {filesize}
 99 | {fileksize} also {filemsize} etc
100 | {fileasize}
101 | ```
102 | 
103 | ### Placeholders
104 | 
105 | The following placeholders can be used in `--subject` and `--message-id` flags.
106 | 
107 | ```
108 | {filenum}   Current file number in collection
109 | {0filenum}  Current file number in collection,
110 |             pre-padded with 0's
111 | {files}     Number of files in collection
112 | {filename}  File's name
113 | {fnamebase} File's name without extension;
114 |             uses same logic as `--group-files`
115 | {filesize}  File's size in bytes
116 | {fileksize} File's size in KiB, rounded to 2dp
117 |             Replace the 'k' with 'm', 'g', 't'
118 |             for sizes in MiB, GiB and TiB
119 |             respectively, e.g. {filemsize}
120 | {fileasize} Friendly formatted file size, e.g.
121 |             '4.85 MiB' or '35.1 GiB'
122 | {part}      Article part number
123 | {0part}     Article part number, pre-padded
124 |             with 0's to be as long as {parts}
125 | {parts}     Number of articles for the file
126 | {size}      Article chunk size (before yEnc)
127 | {comment}   Value from `--comment`
128 | {comment2}  Value from `--comment2`
129 | {timestamp} Unix timestamp of post
130 | ${rand(N)}  Random text, N characters long
131 | ```
132 | 
133 | ## `search`
134 | 
135 | Searches for files matching certain query in the Subject and store results in a
136 | NZB file and outputs the resulting NZB to stdout or a specified output file.
137 | 
138 | ```shell
139 | nzb search --group alt.binaries.test --range 1- Big.Buck.Bunny > bunny.nzb
140 | ```
141 | 
142 | ## `serve`
143 | 
144 | Serves the files specified in an input NZB file as a directory listing.
145 | 
146 | ```shell
147 | nzb serve \
148 |   --addr=0.0.0.0:8000 \
149 |   source.nzb # Source NZB file to serve.
150 | ```
151 | 
152 | A [basic listing template](./index.html) is used when serving. If a custom
153 | template is required, specify its full path with `--template` flag.
154 | 
155 | ```shell
156 | nzb serve \
157 |   --addr=0.0.0.0:8000 \
158 |   --template=~/custom.html
159 |   source.nzb # Source NZB file to serve.
160 | ```
161 | 
162 | This can be useful to display files in the NZB creatively.
163 | 
164 | Each files in the NZB has a route to fetch it via the browser. Regular files are
165 | downloaded, whereas media files are streamed if browser supports.
166 | 
167 | `source.nzb` can be a local or remote URL, and can be gzipped.
168 | 


--------------------------------------------------------------------------------
/get.ts:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env -S deno run --allow-net --allow-env --allow-read
  2 | import {
  3 |   Client,
  4 |   DelimiterStream,
  5 |   endsWith,
  6 |   parseArgs,
  7 |   startsWith,
  8 |   YEncDecoderStream,
  9 | } from "./deps.ts";
 10 | 
 11 | import { File, NZB } from "./model.ts";
 12 | import { fetchNZB } from "./util.ts";
 13 | 
 14 | export function help() {
 15 |   return `NZB Get
 16 |   Fetches a file in an NZB.
 17 | 
 18 | INSTALL:
 19 |   deno install --allow-net --allow-env --allow-read -n nzb-get https://deno.land/x/nzb/get.ts
 20 | 
 21 | USAGE:
 22 |   nzb-get [...options] <input> <filename>
 23 | 
 24 | OPTIONS:
 25 |   --hostname, -h <hostname> The hostname of the NNTP server.
 26 |   --port, -P <port> The port of the NNTP server.
 27 |   --ssl, -S Whether to use SSL.
 28 |   --username, -u <username> Username to authenticate with the NNTP server.
 29 |   --password, -p <password> Password to authenticate with the NNTP server.
 30 |   --start, -s <start> The start of the range of the file to fetch.
 31 |   --end, -e <end> The end of the range of the file to fetch.`;
 32 | }
 33 | 
 34 | const encoder = new TextEncoder();
 35 | const CRLF = encoder.encode("\r\n");
 36 | const YBEGIN = encoder.encode("=ybegin");
 37 | const YPART = encoder.encode("=ypart");
 38 | const YEND = encoder.encode("=yend");
 39 | 
 40 | const parseOptions = {
 41 |   string: [
 42 |     "hostname",
 43 |     "username",
 44 |     "password",
 45 |   ],
 46 |   boolean: [
 47 |     "ssl",
 48 |   ],
 49 |   default: {
 50 |     hostname: Deno.env.get("NNTP_HOSTNAME"),
 51 |     port: Number(Deno.env.get("NNTP_PORT")),
 52 |     username: Deno.env.get("NNTP_USER"),
 53 |     password: Deno.env.get("NNTP_PASS"),
 54 |     ssl: Deno.env.get("NNTP_SSL") === "true",
 55 |     start: 0,
 56 |     end: 0,
 57 |   },
 58 | };
 59 | 
 60 | if (import.meta.main) {
 61 |   get(Deno.args, Deno.stdout.writable);
 62 | }
 63 | 
 64 | /**
 65 |  * Retrieves a file speficified by the given NZB and file name.
 66 |  *
 67 |  * All segments of the file are returned as a single stream, clipped to
 68 |  * the given range if any.
 69 |  * @param {unknown[]} args The argument list.
 70 |  * @param {WritableStream<Uint8Array>} [writable] The writable stream to write to.
 71 |  */
 72 | export async function get(
 73 |   args: unknown[] = Deno.args,
 74 |   output = Deno.stdout.writable,
 75 | ) {
 76 |   const parsedArgs = parseArgs(args as string[], parseOptions);
 77 |   let {
 78 |     _: [input, filename],
 79 |     hostname,
 80 |     port,
 81 |     ssl,
 82 |     username,
 83 |     password,
 84 |     start = 0,
 85 |     end,
 86 |   } = parsedArgs;
 87 | 
 88 |   if (!input || !filename) {
 89 |     console.error("Missing input");
 90 |     console.error(help());
 91 |     return;
 92 |   }
 93 | 
 94 |   const nzb = typeof input === "string"
 95 |     ? await fetchNZB(input)
 96 |     : input as unknown as NZB;
 97 |   const file = typeof filename === "string"
 98 |     ? nzb.file(filename)
 99 |     : filename as unknown as File;
100 | 
101 |   if (!file) {
102 |     console.error(`File "${filename}" not found in NZB`);
103 |     return;
104 |   }
105 | 
106 |   start = Number(start);
107 |   end = Number(end || (file.size - 1));
108 | 
109 |   const client = await Client.connect({
110 |     hostname,
111 |     port: Number(port),
112 |     ssl: !!ssl,
113 |   });
114 | 
115 |   if (username) {
116 |     await client.authinfo(username, password);
117 |   }
118 | 
119 |   const segments = [];
120 |   let size = 0;
121 |   // Collects only segments that will cover the requested range.
122 |   // Note that the boundary of all the segments may be bigger than the range.
123 |   // Instead of storing the segments, we just keep metadata about them, with
124 |   // the additional start and end position relative to the segment.
125 |   for (const segment of file.segments) {
126 |     size += segment.size;
127 |     if (size < start) {
128 |       continue;
129 |     }
130 | 
131 |     const piece = {
132 |       id: segment.id,
133 |       start: 0,
134 |       end: segment.size - 1,
135 |     };
136 | 
137 |     // Handles the first segment within the range.
138 |     if (!segments.length) {
139 |       piece.start = start - (size - segment.size);
140 |     }
141 | 
142 |     segments.push(piece);
143 | 
144 |     // Handles the last segment within the range.
145 |     if (size >= end) {
146 |       piece.end = segment.size - (size - end);
147 |       break;
148 |     }
149 |   }
150 | 
151 |   (async () => {
152 |     for (const segment of segments) {
153 |       const response = await client.body(segment.id);
154 |       await response.body!
155 |         // Splits into lines first
156 |         .pipeThrough(new DelimiterStream(CRLF))
157 |         // Removes yEnc header and trailer lines.
158 |         .pipeThrough(skip([YBEGIN, YPART, YEND]))
159 |         // Decodes the yEnc stream.
160 |         .pipeThrough(new YEncDecoderStream())
161 |         // Trims to data within range
162 |         .pipeThrough(slice(segment.start, segment.end))
163 |         // Sends result to output.
164 |         .pipeTo(output, { preventClose: true });
165 |     }
166 |     // … and signal that we are finished afterwards.
167 |     await output.close();
168 |   })().catch((err) => {
169 |     console.error(err);
170 |   });
171 | }
172 | 
173 | /**
174 |  * Creates a TransformStream that skips chunks that match the given patterns.
175 |  */
176 | function skip(startWith: Uint8Array[] = [], endWith: Uint8Array[] = []) {
177 |   return new TransformStream({
178 |     transform(chunk, controller) {
179 |       if (startWith.some((start) => startsWith(chunk, start))) {
180 |         return;
181 |       }
182 |       if (endWith.some((end) => endsWith(chunk, end))) {
183 |         return;
184 |       }
185 |       controller.enqueue(chunk);
186 |     },
187 |   });
188 | }
189 | 
190 | /**
191 |  * Creates a TransformStream that returns chunks within a range.
192 |  */
193 | function slice(start = 0, end = Number.POSITIVE_INFINITY): TransformStream {
194 |   return new TransformStream({
195 |     transform(chunk, controller) {
196 |       const byteLength = chunk.byteLength;
197 |       const subchunk = chunk.subarray(
198 |         clamp(0, start, byteLength),
199 |         clamp(0, end + 1, byteLength),
200 |       );
201 |       start -= byteLength;
202 |       end -= byteLength;
203 |       if (subchunk.byteLength > 0) {
204 |         controller.enqueue(subchunk);
205 |       }
206 |     },
207 |   });
208 | }
209 | 
210 | function clamp(x: number, lower: number, upper: number) {
211 |   return Math.min(upper, Math.max(lower, x));
212 | }
213 | 


--------------------------------------------------------------------------------
/model.ts:
--------------------------------------------------------------------------------
  1 | import { Article } from "./deps.ts";
  2 | import { yEncParse } from "./util.ts";
  3 | import {
  4 |   Element,
  5 |   HTMLRewriter,
  6 |   TextChunk,
  7 | } from "npm:@worker-tools/html-rewriter@0.1.0-pre.17/base64";
  8 | 
  9 | export class File {
 10 |   poster!: string;
 11 |   /**
 12 |    * The last modified date of the file as the number of milliseconds
 13 |    * since the Unix epoch (January 1, 1970 at midnight). Files without
 14 |    * a known last modified date return the current date.
 15 |    */
 16 |   lastModified!: number;
 17 |   name!: string;
 18 |   size!: number;
 19 |   subject!: string;
 20 |   groups!: string[];
 21 |   segments!: Segment[];
 22 | 
 23 |   constructor(file: File) {
 24 |     Object.assign(this, file);
 25 |   }
 26 | 
 27 |   toString() {
 28 |     const { poster, lastModified, subject, groups, segments } = this;
 29 |     return [
 30 |       `  <file poster="${escapeXml(poster)}" date="${
 31 |         lastModified / 1000
 32 |       }" subject="${escapeXml(subject)}">`,
 33 | 
 34 |       `    <groups>`,
 35 |       `${
 36 |         groups.map((group) =>
 37 |           [
 38 |             `      <group>${group}</group>`,
 39 |           ].join("\n")
 40 |         ).join("\n")
 41 |       }`,
 42 |       `    </groups>`,
 43 | 
 44 |       `    <segments>`,
 45 |       `${
 46 |         segments.map(({ id, size, number }) =>
 47 |           [
 48 |             `      <segment bytes="${size}" number="${number}">${id}</segment>`,
 49 |           ].join("\n")
 50 |         ).join("\n")
 51 |       }`,
 52 |       `    </segments>`,
 53 | 
 54 |       `  </file>`,
 55 |     ].join("\n");
 56 |   }
 57 | }
 58 | 
 59 | export interface Segment {
 60 |   id: string;
 61 |   size: number;
 62 |   number: number;
 63 | }
 64 | 
 65 | /** Output type for most of the commands. */
 66 | export type Output = {
 67 |   readonly writable: WritableStream<Uint8Array>;
 68 | };
 69 | 
 70 | export class NZB implements Iterable<File> {
 71 |   #readable?: ReadableStream;
 72 |   readonly processingInstructions: Record<string, Record<string, string>> = {};
 73 |   readonly head: Record<string, string> = {};
 74 |   readonly files: File[] = [];
 75 |   #segments = 0;
 76 |   name?: string;
 77 |   size = 0;
 78 | 
 79 |   static async from(readable: ReadableStream, name?: string): Promise<NZB> {
 80 |     const nzb = new NZB(readable, name);
 81 |     await nzb.parse();
 82 |     return nzb;
 83 |   }
 84 | 
 85 |   constructor(readable?: ReadableStream, name?: string) {
 86 |     this.#readable = readable;
 87 |     this.name = name;
 88 |   }
 89 | 
 90 |   get segments(): number {
 91 |     return this.#segments;
 92 |   }
 93 | 
 94 |   pi(name: string, data: Record<string, string>) {
 95 |     this.processingInstructions[name] = data;
 96 |   }
 97 | 
 98 |   parse(readable = this.#readable) {
 99 |     if (!readable) {
100 |       return;
101 |     }
102 | 
103 |     let meta = { name: "", value: "" }, group = "";
104 | 
105 |     return new HTMLRewriter()
106 |       .on("head", {
107 |         text: ({ text, lastInTextNode }: TextChunk) => {
108 |           meta.value += text;
109 |           if (lastInTextNode) {
110 |             meta.value = meta.value.trim();
111 |             if (meta.name) {
112 |               this.head[meta.name] = meta.value;
113 |             }
114 |           }
115 |         },
116 |       })
117 |       .on("head > meta", {
118 |         element: (element: Element) => {
119 |           const name = element.getAttribute("type");
120 |           meta = { name, value: "" };
121 |         },
122 |       })
123 |       .on("file > groups > group", {
124 |         element: (element: Element) => {
125 |           const file: File = this.files.at(-1)!;
126 |           group = "";
127 | 
128 |           element.onEndTag(() => {
129 |             file.groups.push(group);
130 |           });
131 |         },
132 |         text: ({ text, lastInTextNode }: TextChunk) => {
133 |           group += text;
134 |           if (lastInTextNode) {
135 |             group = group.trim();
136 |           }
137 |         },
138 |       })
139 |       .on("file", {
140 |         element: (element: Element) => {
141 |           const subject = unescapeXml(element.getAttribute("subject"));
142 |           const file: File = new File({
143 |             poster: element.getAttribute("poster"),
144 |             subject,
145 |             name: "",
146 |             // Stores the seconds specfified in `date` attribute as milliseconds.
147 |             lastModified: Number(element.getAttribute("date")) * 1000,
148 |             size: 0,
149 |             groups: [],
150 |             segments: [],
151 |           });
152 | 
153 |           if (!subject.indexOf("yEnc")) return;
154 |           const { name, size } = yEncParse(subject);
155 |           file.name = name || "";
156 |           file.size = Number(size);
157 | 
158 |           this.files.push(file);
159 | 
160 |           element.onEndTag(() => {
161 |             if (!file.size) {
162 |               file.size = file.segments.reduce(
163 |                 (sum, { size }) => sum + size,
164 |                 0,
165 |               );
166 |             }
167 | 
168 |             this.size += file.size;
169 |           });
170 |         },
171 |       })
172 |       .on("file > segments > segment", {
173 |         element: (element: Element) => {
174 |           const file = this.files.at(-1)!;
175 |           file.segments.push({
176 |             id: "",
177 |             size: Number(element.getAttribute("bytes")),
178 |             number: Number(element.getAttribute("number")),
179 |           });
180 | 
181 |           this.#segments++;
182 |         },
183 |         text: ({ text, lastInTextNode }: TextChunk) => {
184 |           const file = this.files.at(-1)!;
185 |           const segment = file.segments.at(-1)!;
186 |           segment.id += text;
187 |           if (lastInTextNode) {
188 |             segment.id = segment.id.trim();
189 |           }
190 |         },
191 |       })
192 |       .transform(new Response(readable))
193 |       .arrayBuffer(); // Kickstarts the stream.
194 |   }
195 | 
196 |   file(name: string) {
197 |     return this.files.find((file) => file.name === name);
198 |   }
199 | 
200 |   [Symbol.iterator](): Iterator<File> {
201 |     return this.files.values();
202 |   }
203 | 
204 |   articles() {
205 |     return {
206 |       [Symbol.iterator]: () => {
207 |         const files = this.files, lastFile = files.length - 1;
208 |         let currentFile = 0, currentSegment = 0;
209 | 
210 |         return {
211 |           next(): IteratorResult<Article> {
212 |             if (currentFile <= lastFile) {
213 |               const { poster, lastModified, subject, groups, segments } =
214 |                 files[currentFile];
215 |               const total = segments.length;
216 |               if (currentSegment <= (total - 1)) {
217 |                 const { id, number, size } = segments[currentSegment++];
218 |                 const article = new Article({
219 |                   headers: {
220 |                     "from": poster,
221 |                     "date": new Date(lastModified).toUTCString(),
222 |                     // The file's subject is the subject of the first segment, so we
223 |                     // replace it with the current number.
224 |                     "subject": subject.replace(
225 |                       `(1/${total})`,
226 |                       `(${number}/${total})`,
227 |                     ),
228 |                     "newsgroups": groups.join(","),
229 |                     "message-id": `<${id}>`,
230 |                     "bytes": `${size}`,
231 |                   },
232 |                 });
233 |                 article.number = number;
234 |                 return { done: false, value: article };
235 |               } else {
236 |                 currentSegment = 0;
237 |                 currentFile++;
238 |                 return this.next();
239 |               }
240 |             } else {
241 |               return { done: true, value: null };
242 |             }
243 |           },
244 |         };
245 |       },
246 |     };
247 |   }
248 | 
249 |   toString() {
250 |     return [
251 |       `<?xml version="1.0" encoding="utf-8"?>`,
252 |       Object.entries(this.processingInstructions).map(([name, data]) =>
253 |         `<?${name} ${
254 |           Object.entries(data).map(([key, value]) => `${key}="${value}"`).join(
255 |             " ",
256 |           )
257 |         }?>`
258 |       ).join("\n"),
259 |       `<!DOCTYPE nzb PUBLIC "-//newzBin//DTD NZB 1.1//EN" "http://www.newzbin.com/DTD/nzb/nzb-1.1.dtd">`,
260 |       `<nzb xmlns="http://www.newzbin.com/DTD/2003/nzb">`,
261 | 
262 |       `  <head>`,
263 |       `${
264 |         Object.entries(this.head).map(([type, value]) =>
265 |           [
266 |             `    <meta type="${type}">${value}</meta>`,
267 |           ].join("\n")
268 |         ).join("\n")
269 |       }`,
270 |       `  </head>`,
271 | 
272 |       `${this.files.map((file) => `${file}`).join("\n")}`,
273 | 
274 |       `</nzb>`,
275 |     ].join("\n");
276 |   }
277 | }
278 | 
279 | function escapeXml(unsafe: string): string {
280 |   return unsafe.replace(/[<>&'"]/g, function (c) {
281 |     switch (c) {
282 |       case `<`:
283 |         return `&lt;`;
284 |       case `>`:
285 |         return `&gt;`;
286 |       case `&`:
287 |         return `&amp;`;
288 |       case `'`:
289 |         return `&apos;`;
290 |       case `"`:
291 |         return `&quot;`;
292 |       default:
293 |         return c;
294 |     }
295 |   });
296 | }
297 | 
298 | function unescapeXml(escaped: string): string {
299 |   return escaped.replace(/&lt;|&gt;|&amp;|&apos;|&quot;/g, function (c) {
300 |     switch (c) {
301 |       case `&lt;`:
302 |         return `<`;
303 |       case `&gt;`:
304 |         return `>`;
305 |       case `&amp;`:
306 |         return `&`;
307 |       case `&apos;`:
308 |         return `'`;
309 |       case `&quot;`:
310 |         return `"`;
311 |       default:
312 |         return c;
313 |     }
314 |   });
315 | }
316 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/mirror.ts:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env -S deno run --allow-net --allow-env --allow-read --allow-write
  2 | import {
  3 |   Article,
  4 |   basename,
  5 |   extname,
  6 |   parseArgs,
  7 |   pooledMap,
  8 |   prettyBytes,
  9 | } from "./deps.ts";
 10 | 
 11 | import { mirrorArticle } from "./mirrorArticle.ts";
 12 | import { fetchNZB, Progress } from "./util.ts";
 13 | 
 14 | export function help() {
 15 |   return `NZB Mirror
 16 |   Mirrors an NZB file.
 17 | 
 18 | INSTALL:
 19 |   deno install --allow-net --allow-env --allow-read --allow-write -n nzb-mirror https://deno.land/x/nzb/mirror.ts
 20 | 
 21 | USAGE:
 22 |   nzb-mirror [...options] <input>
 23 | 
 24 | OPTIONS:
 25 |   --hostname, -h <hostname> The hostname of the NNTP server.
 26 |   --port, -P <port> The port of the NNTP server.
 27 |   --ssl, -S Whether to use SSL.
 28 |   --username, -u <username> The username to authenticate with.
 29 |   --password, -p <password> The password to authenticate with.
 30 |   --connections, -n <connections> The number of connections to use.
 31 |   --connect-retries, -r <connect-retries> The number of retries to connect.
 32 |   --reconnect-delay, -d <reconnect-delay> The delay between reconnects.
 33 |   --request-retries, -R <request-retries> The number of retries to request.
 34 |   --post-retry-delay, -D <post-retry-delay> The delay between retries.
 35 |   --comment, -t <comment> The comment to use.
 36 |   --comment2, -T <comment2> The second comment to use.
 37 |   --subject, -s <subject> The subject to use.
 38 |   --from, -f <from> The from address to use.
 39 |   --groups, -g <groups> The groups to post to.
 40 |   --date, -D <date> The date to use.
 41 |   --message-id, -m <message-id> The message-id to use.
 42 |   --out, -o <out> The output file.
 43 |   --progress, -p Whether to show progress.`;
 44 | }
 45 | 
 46 | const encoder = new TextEncoder();
 47 | 
 48 | const parseOptions = {
 49 |   string: [
 50 |     "hostname",
 51 |     "port",
 52 |     "username",
 53 |     "password",
 54 |     "connections",
 55 |     "connect-retries",
 56 |     "reconnect-delay",
 57 |     "request-retries",
 58 |     "post-retry-delay",
 59 | 
 60 |     "comment",
 61 |     "comment2",
 62 |     "subject",
 63 | 
 64 |     "from",
 65 |     "groups",
 66 |     "date",
 67 |     "message-id", // Format of generated Message-ID. Default to `${uuid}@nntp`
 68 |   ],
 69 |   boolean: [
 70 |     "ssl",
 71 |     "progress",
 72 |   ],
 73 |   alias: {
 74 |     "hostname": ["host", "h"],
 75 |     "port": "P",
 76 |     "ssl": "S",
 77 |     "username": ["user", "u"],
 78 |     "password": ["passw", "p"],
 79 |     "connections": "n",
 80 | 
 81 |     "comment": "t",
 82 |     "subject": "s",
 83 |     "from": "f",
 84 |     "groups": "g",
 85 |     "messageId": ["message-id"],
 86 |   },
 87 |   default: {
 88 |     hostname: Deno.env.get("NNTP_HOSTNAME"),
 89 |     port: Deno.env.get("NNTP_PORT"),
 90 |     ssl: Deno.env.get("NNTP_SSL") === "true",
 91 |     username: Deno.env.get("NNTP_USER"),
 92 |     password: Deno.env.get("NNTP_PASS"),
 93 |     connections: Number(Deno.env.get("NNTP_CONNECTIONS") || 3),
 94 |     from: Deno.env.get("NNTP_POSTER") || "poster@example.com",
 95 |     groups: "",
 96 |     date: "",
 97 |     messageId: "",
 98 |   },
 99 | };
100 | 
101 | if (import.meta.main) {
102 |   await mirror(Deno.args, Deno.stdout.writable);
103 | }
104 | 
105 | /**
106 |  * Mirrors an NZB to another
107 |  *
108 |  * For each files in the article, retrieves its segments and re-posts
109 |  * them, using the original NZB headers or ones provided from options.
110 |  *
111 |  * The new segments and files are gathered into a new NZB.
112 |  */
113 | export async function mirror(
114 |   args = Deno.args,
115 |   writable = Deno.stdout.writable,
116 | ): Promise<void> {
117 |   const parsedArgs = parseArgs(args as string[], parseOptions);
118 |   let {
119 |     _: [input],
120 |     connections,
121 |     comment = "",
122 |     comment2 = "",
123 |     subject = "",
124 |     from,
125 |     groups,
126 |     date,
127 |     messageId,
128 |     progress,
129 |   } = parsedArgs;
130 | 
131 |   if (!input) {
132 |     console.error("Missing input");
133 |     console.error(help());
134 |     return;
135 |   }
136 | 
137 |   const nzb = await fetchNZB(input as string);
138 |   const { size, head, files } = nzb;
139 | 
140 |   const output = writable.getWriter();
141 | 
142 |   // `date` can have the special value 'now' to refer script's start time.
143 |   if (date === "now") {
144 |     date = new Date().toUTCString();
145 |   }
146 | 
147 |   function writeln(lines: string | string[], ending = "\n") {
148 |     if (!output) return Promise.resolve(0);
149 |     if (!Array.isArray(lines)) {
150 |       lines = [lines];
151 |     }
152 |     // Filters out undefined lines.
153 |     lines = lines.filter((x) => x);
154 |     return output.write(encoder.encode(lines.join(ending) + ending));
155 |   }
156 | 
157 |   let completed = 0; /** Number of bytes posted. */
158 |   if (progress) {
159 |     const progressBar = new Progress({
160 |       title: `Mirroring using ${connections} connections`,
161 |       total: size,
162 |       complete: "=",
163 |       incomplete: "-",
164 |       display:
165 |         "[:bar] :completed/:total (:percent) - :rate/s - :time (ETA :eta)",
166 |     });
167 | 
168 |     // Keeps updating progress every 1s instead of every article done.
169 |     const progressInterval = setInterval(() => {
170 |       progressBar.render(completed, {});
171 | 
172 |       if (completed >= size) {
173 |         clearInterval(progressInterval);
174 |       }
175 |     }, 1000);
176 |   }
177 | 
178 |   /** Writes head lines first if any. */
179 |   const headlines = Object.entries(head).map(([type, value]) =>
180 |     [
181 |       `    <meta type="${type}">${value}</meta>`,
182 |     ].join("\n")
183 |   );
184 | 
185 |   await writeln([
186 |     `<?xml version="1.0" encoding="utf-8"?>`,
187 |     `<!DOCTYPE nzb PUBLIC "-//newzBin//DTD NZB 1.1//EN" "http://www.newzbin.com/DTD/nzb/nzb-1.1.dtd">`,
188 |     `<nzb xmlns="http://www.newzbin.com/DTD/2003/nzb">`,
189 |   ]);
190 | 
191 |   if (headlines.length) {
192 |     await writeln([
193 |       `  <head>`,
194 |       `${headlines.join("\n")}`,
195 |       `  </head>`,
196 |     ]);
197 |   }
198 | 
199 |   let filenum = 1;
200 |   const results = pooledMap(connections, nzb.articles(), async (article) => {
201 |     const {
202 |       name: filename,
203 |       size: filesize,
204 |       lastModified,
205 |       segments,
206 |     } = files.at(filenum - 1)!;
207 |     const { headers, number } = article;
208 |     let newSubject = headers.get("subject")!;
209 |     const bytes = headers.get("bytes")!;
210 |     let newMessageId = "";
211 | 
212 |     if (subject || messageId) {
213 |       const params: Record<string, string | number> = {
214 |         /** Current file number in collection */
215 |         filenum,
216 |         /** Current file number in collection, pre-padded with 0's */
217 |         "0filenum": `${filenum}`.padStart(`${files.length}`.length, "0"),
218 |         /** Number of files in collection */
219 |         files: files.length,
220 |         /** File's name */
221 |         filename,
222 |         /** File's name without extension */
223 |         fnamebase: basename(filename, extname(filename)),
224 |         /** File's size in bytes */
225 |         filesize,
226 |         /** File's size in KiB, rounded to 2dp */
227 |         fileksize: (filesize / 1000).toFixed(2),
228 |         /** File's size in MiB, rounded to 2dp */
229 |         filemsize: (filesize / 1000 / 1000).toFixed(2),
230 |         /** File's size in GiB, rounded to 2dp */
231 |         filegsize: (filesize / 1000 / 1000 / 1000).toFixed(2),
232 |         /** File's size in TiB, rounded to 2dp */
233 |         filetsize: (filesize / 1000 / 1000 / 1000 / 1000).toFixed(2),
234 |         /** Friendly formatted file size, e.g. '4.85 MiB' or '35.1 GiB' */
235 |         fileasize: prettyBytes(filesize),
236 |         /** Article part number */
237 |         part: number as number,
238 |         /** Article part number, pre-padded with 0's to be as long as {parts} */
239 |         "0part": `${number}`.padStart(`${segments.length}`.length, "0"),
240 |         /** Number of articles for the file */
241 |         parts: segments.length,
242 |         /** Article chunk size */
243 |         size: bytes,
244 |         /** Value from `--comment` */
245 |         comment,
246 |         /** Value from `--comment2` */
247 |         comment2,
248 |         /** Unix timestamp of post */
249 |         timestamp: lastModified / 1000,
250 |       };
251 | 
252 |       const replacer = (_match: string, name: string) => `${params[name]}`;
253 | 
254 |       if (subject) {
255 |         newSubject = subject.replace(
256 |           /{(.*?)}/g,
257 |           replacer,
258 |         ).replace(
259 |           /\$\{rand\(([\d]+)\)\}/,
260 |           (_: string, n: string) => rand(Number(n)),
261 |         );
262 |       }
263 | 
264 |       if (messageId) {
265 |         newMessageId = subject.replace(
266 |           /{(.*?)}/g,
267 |           replacer,
268 |         ).replace(
269 |           /\$\{rand\(([\d]+)\)\}/,
270 |           (_: string, n: string) => rand(Number(n)),
271 |         );
272 | 
273 |         if (!/^<.*>$/.test(newMessageId)) {
274 |           newMessageId = `<${newMessageId}>`;
275 |         }
276 |       }
277 |     }
278 | 
279 |     if (number === segments.length) {
280 |       filenum++;
281 |     }
282 | 
283 |     const argv: unknown[] = [article];
284 |     Object.entries(parsedArgs).forEach(([key, value]) => {
285 |       argv.push(`--${key}`);
286 |       argv.push(`${value}`);
287 |     });
288 |     const result = await mirrorArticle(
289 |       argv,
290 |       new Article({
291 |         headers: {
292 |           /** Uses the new `date` if any. */
293 |           date,
294 |           /** Uses the `from` flag if any. */
295 |           from,
296 |           /** Bytes header remains the same. */
297 |           bytes,
298 |           /** Uses the `groups` flag if any. */
299 |           newsgroups: groups,
300 |           /** Transforms subject from template specified in `subject` flag if any. */
301 |           subject: newSubject,
302 |           /** Transforms message-id from template specified in `message-d` flag if any. */
303 |           "message-id": newMessageId,
304 |         },
305 |       }),
306 |     );
307 | 
308 |     result!.number = number;
309 | 
310 |     return result;
311 |   });
312 | 
313 |   let index = 0;
314 |   for await (const article of results) {
315 |     const { number, headers } = article!;
316 |     const date = headers.get("date")!;
317 |     const from = headers.get("from")!;
318 |     const newsgroups = headers.get("newsgroups")!;
319 |     const subject = headers.get("subject")!;
320 |     const id = headers.get("message-id")!;
321 |     const bytes = +headers.get("bytes")!;
322 | 
323 |     // Wraps with a `<file>` node if it's the first article (with number 1).
324 |     if (number === 1) {
325 |       // However, if this is not the very first article in the NZB, we need to close previous file.
326 |       if (index) {
327 |         await writeln([
328 |           `    </segments>`,
329 |           `  </file>`,
330 |         ]);
331 |       }
332 | 
333 |       await writeln([
334 |         `  <file poster="${escape(from)}" date="${
335 |           (+new Date(date)) / 1000
336 |         }" subject="${escape(subject)}">`,
337 |         `    <groups>`,
338 |         `${
339 |           newsgroups.split(",").map((group: string) =>
340 |             [
341 |               `      <group>${group}</group>`,
342 |             ].join("\n")
343 |           ).join("\n")
344 |         }`,
345 |         `    </groups>`,
346 | 
347 |         `    <segments>`,
348 |       ]);
349 |     }
350 | 
351 |     await writeln(
352 |       `      <segment bytes="${bytes}" number="${number}">${
353 |         id.replace(/<([^>]+)>/, "$1")
354 |       }</segment>`,
355 |     );
356 | 
357 |     completed += bytes;
358 |     index++;
359 |   }
360 | 
361 |   await writeln([
362 |     `    </segments>`,
363 |     `  </file>`,
364 |     `</nzb>`,
365 |   ]);
366 | 
367 |   output.close();
368 | }
369 | 
370 | function escape(html: string): string {
371 |   return html.replace(/&/g, "&amp;")
372 |     .replace(/</g, "&lt;")
373 |     .replace(/>/g, "&gt;")
374 |     .replace(/"/g, "&quot;")
375 |     .replace(/'/g, "&#39;");
376 | }
377 | 
378 | /**
379 |  * Generates a random string of N length.
380 |  */
381 | function rand(n: number): string {
382 |   const array = new Uint8Array((n || 40) / 2);
383 |   crypto.getRandomValues(array);
384 |   return Array.from(array, dec2hex).join("");
385 | }
386 | 
387 | /**
388 |  * Converts decimal to hex string.
389 |  */
390 | function dec2hex(dec: number): string {
391 |   return dec.toString(16).padStart(2, "0");
392 | }
393 | 


--------------------------------------------------------------------------------
/serve.ts:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env -S deno run --allow-net --allow-env --allow-read
  2 | import {
  3 |   basename,
  4 |   contentType,
  5 |   encodeHex,
  6 |   extname,
  7 |   ifNoneMatch,
  8 |   parseArgs,
  9 |   STATUS_CODE,
 10 |   STATUS_TEXT,
 11 | } from "./deps.ts";
 12 | 
 13 | import { NZB } from "./model.ts";
 14 | import { extract } from "./extract.ts";
 15 | import { get } from "./get.ts";
 16 | import { fetchNZB } from "./util.ts";
 17 | 
 18 | export function help() {
 19 |   return `NZB Server
 20 |   Serves content of an NZB file.
 21 | 
 22 | INSTALL:
 23 |   deno install --allow-net --allow-env --allow-read -n nzb-serve https://deno.land/x/nzb/serve.ts
 24 | 
 25 | USAGE:
 26 |   nzb-serve [...options] <input>
 27 | 
 28 | OPTIONS:
 29 |   --address, -addr <address> IPaddress:Port or :Port to bind server to (default "127.0.0.1:8000")
 30 |   --template, -t <template> Path to HTML template to use (default "./index.html")
 31 |   --hostname, -h <hostname> Hostname of the NNTP server (default "localhost")
 32 |   --port, -P <port> Port of the NNTP server (default "8080")
 33 |   --ssl, -S <true|false> Whether to use SSL (default false)
 34 |   --username, -u <username> Username to authenticate with the NNTP server
 35 |   --password, -p <password> Password to authenticate with the NNTP server
 36 |   --verbose, -v <true|false> Whether to log requests (default false)`;
 37 | }
 38 | 
 39 | const DEFAULT_TEMPLATE = "./index.xsl";
 40 | 
 41 | const encoder = new TextEncoder();
 42 | 
 43 | const parseOptions = {
 44 |   string: [
 45 |     "address",
 46 |     "template",
 47 |     "hostname",
 48 |     "username",
 49 |     "password",
 50 |   ],
 51 |   boolean: [
 52 |     "ssl",
 53 |     "verbose",
 54 |   ],
 55 |   default: {
 56 |     address: "127.0.0.1:8000",
 57 |     template: DEFAULT_TEMPLATE,
 58 |     hostname: Deno.env.get("NNTP_HOSTNAME"),
 59 |     port: Number(Deno.env.get("NNTP_PORT")),
 60 |     username: Deno.env.get("NNTP_USER"),
 61 |     password: Deno.env.get("NNTP_PASS"),
 62 |     ssl: Deno.env.get("NNTP_SSL") === "true",
 63 |     verbose: false,
 64 |   },
 65 | };
 66 | 
 67 | if (import.meta.main) {
 68 |   serve(Deno.args, Deno.serve);
 69 | }
 70 | 
 71 | /**
 72 |  * Serves an input NZB.
 73 |  *
 74 |  * This is a handler to be passed to a web server like `Deno.serve` to
 75 |  * serve the input NZB as listing with `serveNZBIndex`, and routes file
 76 |  * requests to `serveFile`.
 77 |  */
 78 | function serve(args = Deno.args, server = Deno.serve) {
 79 |   const parsedArgs = parseArgs(args as string[], parseOptions);
 80 |   const {
 81 |     _: [input = ""],
 82 |     address,
 83 |     template,
 84 |     verbose,
 85 |   } = parsedArgs;
 86 | 
 87 |   if (!input) {
 88 |     console.error("Missing input");
 89 |     console.error(help());
 90 |     return;
 91 |   }
 92 |   const [hostname, port] = address.split(":");
 93 | 
 94 |   server({ hostname, port: Number(port) }, async (request) => {
 95 |     const url = new URL(request.url);
 96 |     const { searchParams } = url;
 97 | 
 98 |     if (!searchParams.get("template")) {
 99 |       searchParams.set("template", template);
100 |     }
101 | 
102 |     if (!searchParams.get("url")) {
103 |       searchParams.set("url", input as string);
104 |     }
105 | 
106 |     // Reconstruct the URL with the new search params
107 |     request = new Request(url, request);
108 |     const response = await router(request);
109 |     if (verbose) {
110 |       serverLog(request, response.status);
111 |     }
112 | 
113 |     return response;
114 |   });
115 | }
116 | 
117 | /**
118 |  * Serves content of NZB file
119 |  *
120 |  * The NZB URL must be passed as search paramter `url`. Both uncompressed
121 |  * or gzipped NZB files are supported. The provided NZB URL is used to
122 |  * construct an `NZB` object which is used to serve its content.
123 |  *
124 |  * ```ts
125 |  * import { router } from "./serve.ts";
126 |  *
127 |  * await Deno.serve((request) => {
128 |  *   const url = new URL(request.url);
129 |  *   const { searchParams } = url;
130 |  *
131 |  *   // Defaults to a specific NZB
132 |  *   if (!searchParams.get("url")) {
133 |  *     searchParams.set("url", "https://sabnzbd.org/tests/test_download_100MB.nzb");
134 |  *   }
135 |  *
136 |  *   // Reconstruct the URL with the new search params
137 |  *   request = new Request(url, request);
138 |  *   return router(request);
139 |  * );
140 |  * ```
141 |  *
142 |  * The request can have an `action` query parameter which is used to
143 |  * determine the action to take on the files. There must be form data
144 |  * with a "files" field associated with the action. The "files" will be
145 |  * applied with the requested action.
146 |  *
147 |  * Right now the only supported action is "extract".
148 |  *
149 |  * By default, the listing is rendered using the built-in `index.xsl`
150 |  * template, which simply displays the NZB information and its files as
151 |  * clickable links, which can be downloaded or streamed.
152 |  *
153 |  * This template can be changed by setting `template` query parameter
154 |  * to another URL. The template could do anything using NZB content as
155 |  * XML data. See `index.xsl` for an example.
156 |  *
157 |  * Even though the base template is static HTML, there should not be
158 |  * any stopping you from going full SPA (Single Page Application) with
159 |  * it. You can even have a template the returns JSON instead, and serve
160 |  * your own index page.
161 |  */
162 | function router(request: Request) {
163 |   const url = new URL(request.url);
164 |   const { pathname, searchParams } = url;
165 | 
166 |   if (pathname === "/favicon.ico") {
167 |     return new Response(null);
168 |   }
169 | 
170 |   // Template request from the NZB.
171 |   if (pathname === "/index.xsl") {
172 |     return fetch(
173 |       new URL(searchParams.get("template")!, import.meta.url).href,
174 |     );
175 |   }
176 | 
177 |   if (pathname === "/") {
178 |     return index(request);
179 |   }
180 | 
181 |   return file(request);
182 | }
183 | 
184 | const exports = {
185 |   fetch: router,
186 | };
187 | 
188 | export {
189 |   // For Cloudflare Workers.
190 |   exports as default,
191 |   router as fetch,
192 |   serve,
193 | };
194 | 
195 | /**
196 |  * List files in an NZB.
197 |  * @param {Request} request
198 |  * @returns {Promise<Response>}
199 |  */
200 | async function index(request: Request) {
201 |   const { searchParams } = new URL(request.url);
202 |   const url = searchParams.get("url");
203 | 
204 |   if (!url) {
205 |     return new Response(null, { status: STATUS_CODE.BadRequest });
206 |   }
207 | 
208 |   let nzb = await fetchNZB(url);
209 | 
210 |   const name = basename(nzb.name as string);
211 |   const query = searchParams.get("q");
212 |   const action = searchParams.get("action");
213 | 
214 |   if (query) {
215 |     const files = nzb.files;
216 |     nzb = new NZB();
217 |     files.forEach((file) => {
218 |       if (file.name.match(query as string)) {
219 |         (nzb as NZB).files.push(file);
220 |       }
221 |     });
222 |   }
223 | 
224 |   const headers = new Headers();
225 |   const status = 200;
226 | 
227 |   if (action === "extract") {
228 |     const formData = await request.formData();
229 |     const files = formData.getAll("files") as string[];
230 | 
231 |     headers.set("Content-Type", "application/x-nzb");
232 |     headers.set(
233 |       "Content-Disposition",
234 |       `attachment; filename="partial-${name}"`,
235 |     );
236 | 
237 |     const { readable, writable } = new TransformStream();
238 |     extract([nzb as unknown, files.map(escapeRegExp).join("|")], writable);
239 | 
240 |     return new Response(readable, { status, headers });
241 |   }
242 | 
243 |   headers.set("Content-Type", "text/xml");
244 |   // Set "Accept-Ranges" so that the client knows it can make range requests on future requests
245 |   headers.set("Accept-Ranges", "bytes");
246 |   headers.set("Date", new Date().toUTCString());
247 | 
248 |   nzb.pi("xml-stylesheet", { type: "text/xsl", href: "index.xsl" });
249 | 
250 |   return new Response(nzb.toString(), { status, headers });
251 | }
252 | 
253 | /**
254 |  * Serves a request for a file inside an NZB.
255 |  *
256 |  * The file is requested through NNTP and streamed back to the
257 |  * client. It is up to the client to handle the response, whether to
258 |  * play the media file, or to ask the user to save it to disk.
259 |  *
260 |  * Range request is supported.
261 |  *
262 |  * Internally, the handler normalizes the request and passes to `get`
263 |  * to do the fetching and streaming. All NNTP information are retrieved
264 |  * from environment variables, unless specified through querystring.
265 |  *
266 |  * See `get` for the list of parameters.
267 |  *
268 |  * @param {Request} request
269 |  * @returns {Promise<Response>}
270 |  */
271 | async function file(request: Request) {
272 |   const { pathname, searchParams } = new URL(request.url);
273 |   const url = searchParams.get("url");
274 | 
275 |   if (!url) {
276 |     return new Response(null, { status: STATUS_CODE.BadRequest });
277 |   }
278 | 
279 |   const nzb = await fetchNZB(url);
280 |   const file = nzb.file(decodeURI(pathname.substring(1)));
281 | 
282 |   if (!file) {
283 |     return new Response(null, { status: STATUS_CODE.NotFound });
284 |   }
285 | 
286 |   const headers = new Headers();
287 |   // Set "Accept-Ranges" so that the client knows it can make range requests on future requests
288 |   headers.set("Accept-Ranges", "bytes");
289 |   headers.set("Date", new Date().toUTCString());
290 | 
291 |   // Set mime-type using the file extension in filePath
292 |   const contentTypeValue = contentType(extname(file.name));
293 |   if (contentTypeValue) {
294 |     headers.set("Content-Type", contentTypeValue);
295 |   }
296 | 
297 |   if (extname(file.name) === ".mkv") {
298 |     // Chrome needs this changed to play MKV.
299 |     headers.set("Content-Type", "video/webm");
300 |   }
301 | 
302 |   let status: number = STATUS_CODE.OK;
303 |   const responseInit: ResponseInit = { headers };
304 |   // Custom getter for status code and text.
305 |   Object.defineProperties(responseInit, {
306 |     status: {
307 |       get() {
308 |         return status;
309 |       },
310 |     },
311 |     statusText: {
312 |       get() {
313 |         return (STATUS_TEXT as Record<number, string>)[status];
314 |       },
315 |     },
316 |   });
317 | 
318 |   // Set date header if access timestamp is available
319 |   // if (file.atime instanceof Date) {
320 |   //   const date = new Date(file.atime);
321 |   //   headers.set("date", date.toUTCString());
322 |   // }
323 | 
324 |   // Set last modified header
325 |   if (file.lastModified) {
326 |     const lastModified = new Date(file.lastModified);
327 |     headers.set("Last-Modified", lastModified.toUTCString());
328 | 
329 |     // Create a simple etag that is an md5 of the last modified date and filesize concatenated
330 |     const simpleEtag = await createEtagHash(
331 |       `${lastModified.toJSON()}${file.size}`,
332 |       "fnv1a",
333 |     );
334 |     headers.set("ETag", simpleEtag);
335 | 
336 |     // If a `If-None-Match` header is present and the value matches the tag or
337 |     // if a `If-Modified-Since` header is present and the value is bigger than
338 |     // the access timestamp value, then return 304
339 |     const ifNoneMatchValue = request.headers.get("If-None-Match");
340 |     const ifModifiedSince = request.headers.get("If-Modified-Since");
341 |     if (
342 |       (ifNoneMatchValue && ifNoneMatch(ifNoneMatchValue, simpleEtag)) ||
343 |       (ifNoneMatchValue === null &&
344 |         ifModifiedSince &&
345 |         file.lastModified < new Date(ifModifiedSince).getTime() + 1000)
346 |     ) {
347 |       status = STATUS_CODE.NotModified;
348 |       return new Response(null, responseInit);
349 |     }
350 |   }
351 | 
352 |   // Get and parse the "range" header
353 |   const range = request.headers.get("Range") as string;
354 |   const rangeRe = /bytes=(\d+)-(\d+)?/;
355 |   const parsed = rangeRe.exec(range);
356 | 
357 |   // Use the parsed value if available, fallback to the start and end of the entire file
358 |   const start = parsed && parsed[1] ? +parsed[1] : 0;
359 |   const end = parsed && parsed[2] ? +parsed[2] : file.size - 1;
360 | 
361 |   // If there is a range, set the status to 206, and set the "Content-Range" header.
362 |   if (range && parsed) {
363 |     headers.set("Content-Range", `bytes ${start}-${end}/${file.size}`);
364 |   }
365 | 
366 |   // Return 416 if `start` isn't less than or equal to `end`, or `start` or `end` are greater than the file's size
367 |   const maxRange = file.size - 1;
368 | 
369 |   if (
370 |     range &&
371 |     (!parsed ||
372 |       typeof start !== "number" ||
373 |       start > end ||
374 |       start > maxRange ||
375 |       end > maxRange)
376 |   ) {
377 |     status = STATUS_CODE.RangeNotSatisfiable;
378 |     return new Response(responseInit.statusText, responseInit);
379 |   }
380 | 
381 |   // Set content length
382 |   const contentLength = end - start + 1;
383 |   headers.set("Content-Length", `${contentLength}`);
384 | 
385 |   if (request.method === "HEAD") {
386 |     return new Response(null, responseInit);
387 |   }
388 | 
389 |   searchParams.set("start", `${start}`);
390 |   searchParams.set("end", `${end}`);
391 | 
392 |   const argv: unknown[] = [nzb, file];
393 |   [
394 |     "hostname",
395 |     "port",
396 |     "ssl",
397 |     "username",
398 |     "password",
399 |     "start",
400 |     "end",
401 |   ].forEach((key) => {
402 |     const value = searchParams.get(key);
403 |     if (value) {
404 |       argv.push(`--${key}`);
405 |       argv.push(`${value}`);
406 |     }
407 |   });
408 |   // Uses a default transform stream that `get` can write to.
409 |   const { readable, writable } = new TransformStream();
410 |   get(argv, writable);
411 | 
412 |   if (range && parsed) {
413 |     status = STATUS_CODE.PartialContent;
414 |   }
415 | 
416 |   return new Response(readable, responseInit);
417 | }
418 | 
419 | function serverLog(req: Request, status: number): void {
420 |   const d = new Date().toISOString();
421 |   const dateFmt = `[${d.slice(0, 10)} ${d.slice(11, 19)}]`;
422 |   const normalizedUrl = new URL(req.url).pathname;
423 |   const s = `${dateFmt} [${req.method}] ${normalizedUrl} ${status}`;
424 |   // using console.debug instead of console.log so chrome inspect users can hide request logs
425 |   console.debug(s);
426 | }
427 | 
428 | function escapeRegExp(string: string) {
429 |   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
430 | }
431 | 
432 | // The fnv-1a hash function.
433 | function fnv1a(buf: string): string {
434 |   let hash = 2166136261; // 32-bit FNV offset basis
435 |   for (let i = 0; i < buf.length; i++) {
436 |     hash ^= buf.charCodeAt(i);
437 |     // Equivalent to `hash *= 16777619` without using BigInt
438 |     // 32-bit FNV prime
439 |     hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) +
440 |       (hash << 24);
441 |   }
442 |   // 32-bit hex string
443 |   return (hash >>> 0).toString(16);
444 | }
445 | 
446 | /** Algorithm used to determine etag */
447 | export type EtagAlgorithm =
448 |   | "fnv1a"
449 |   | "sha-1"
450 |   | "sha-256"
451 |   | "sha-384"
452 |   | "sha-512";
453 | 
454 | // Generates a hash for the provided string
455 | async function createEtagHash(
456 |   message: string,
457 |   algorithm: EtagAlgorithm = "fnv1a",
458 | ): Promise<string> {
459 |   if (algorithm === "fnv1a") {
460 |     return fnv1a(message);
461 |   }
462 |   const msgUint8 = encoder.encode(message);
463 |   const hashBuffer = await crypto.subtle.digest(algorithm, msgUint8);
464 |   return encodeHex(new Uint8Array(hashBuffer));
465 | }
466 | 


--------------------------------------------------------------------------------