tex2pdf-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 harshpreet931
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# tex2pdf-cli
+
+Convert TeX files to PDF with zero setup.
+
+## Usage
+
+```bash
+npx tex2pdf-cli document.tex
+```
+
+LaTeX is automatically installed on first use (~200MB download).
+
+## Installation
+
+```bash
+npm install -g tex2pdf-cli
+```
+
+## Options
+
+```bash
+tex2pdf document.tex [output.pdf] [--engine=ENGINE]
+```
+
+| Option | Description |
+|--------|-------------|
+| `--engine=ENGINE` | LaTeX engine: `xelatex` (default), `pdflatex`, `lualatex` |
+| `--install` | Force reinstall TinyTeX |
+| `--help` | Show help |
+
+## License
+
+MIT

package/cli.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const latex = require('node-latex');
+const { hasLaTeX, getEnginePath, findTinyTeX } = require('./find-latex');
+const { fixTinyTeXSymlinks } = require('./install-latex');
+
+const args = process.argv.slice(2);
+
+function showHelp() {
+  console.log(`
+Usage: tex2pdf <input.tex> [output.pdf] [options]
+
+Convert TeX files to PDF instantly with zero setup.
+LaTeX is auto-installed on first use if not present.
+
+Arguments:
+  input.tex     Path to your TeX file
+  output.pdf    Output PDF path (optional, defaults to input.pdf)
+
+Options:
+  --engine      LaTeX engine: pdflatex (default), xelatex, lualatex
+  --install     Force re/install LaTeX (TinyTeX)
+  --help        Show this help message
+
+Examples:
+  tex2pdf document.tex
+  tex2pdf document.tex output.pdf
+  tex2pdf document.tex --engine=xelatex
+  npx tex2pdf-cli document.tex
+
+First run may take a few minutes to download LaTeX (~200MB).
+`);
+}
+
+async function runInstallScript() {
+  console.log('LaTeX not found. Installing TinyTeX automatically...');
+  console.log('  This is a one-time setup (~200MB download)');
+  console.log('');
+  
+  return new Promise((resolve, reject) => {
+    const installScript = path.join(__dirname, 'install-latex.js');
+    const child = spawn('node', [installScript], {
+      stdio: 'inherit'
+    });
+    
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error('Installation failed'));
+      }
+    });
+    
+    child.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+async function ensureLaTeX() {
+  if (hasLaTeX()) {
+    fixTinyTeXSymlinks();
+    return true;
+  }
+
+  try {
+    await runInstallScript();
+    fixTinyTeXSymlinks();
+    return hasLaTeX();
+  } catch (error) {
+    console.error('\nFailed to install LaTeX automatically.');
+    console.error('  You can install it manually from:');
+    console.error('  - https://tug.org/texlive/ (TeX Live)');
+    console.error('  - https://miktex.org/ (MiKTeX for Windows)');
+    console.error('  - https://yihui.org/tinytex/ (TinyTeX)');
+    return false;
+  }
+}
+
+async function convertFile(inputPath, outputPath, engine) {
+  if (!fs.existsSync(inputPath)) {
+    console.error(`Error: File not found: ${inputPath}`);
+    process.exit(1);
+  }
+
+  const enginePath = getEnginePath(engine);
+  if (!enginePath) {
+    console.error(`Error: LaTeX engine "${engine}" not found`);
+    process.exit(1);
+  }
+
+  const input = fs.createReadStream(inputPath);
+  const output = fs.createWriteStream(outputPath);
+
+  console.log(`Converting ${path.basename(inputPath)}...`);
+
+  const pdf = latex(input, { 
+    cmd: enginePath,
+    inputs: path.dirname(inputPath)
+  });
+
+  pdf.pipe(output);
+
+  return new Promise((resolve, reject) => {
+    pdf.on('error', (err) => {
+      reject(err);
+    });
+
+    output.on('finish', () => {
+      console.log(`Created: ${outputPath}`);
+      resolve();
+    });
+  });
+}
+
+async function main() {
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (args.includes('--install')) {
+    console.log('Force installing LaTeX...');
+    await runInstallScript();
+    process.exit(0);
+  }
+
+  const latexReady = await ensureLaTeX();
+  if (!latexReady) {
+    process.exit(1);
+  }
+
+  const inputFile = args[0];
+  let outputFile = null;
+  let engine = 'xelatex';
+
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--engine=')) {
+      engine = arg.split('=')[1];
+    } else if (arg.startsWith('--')) {
+      console.error(`Unknown option: ${arg}`);
+      process.exit(1);
+    } else if (!outputFile) {
+      outputFile = arg;
+    }
+  }
+
+  if (!outputFile) {
+    const parsed = path.parse(inputFile);
+    outputFile = path.join(parsed.dir, `${parsed.name}.pdf`);
+  }
+
+  try {
+    await convertFile(inputFile, outputFile, engine);
+  } catch (err) {
+    if (engine === 'pdflatex' && err.message.includes('Font')) {
+      console.log(`pdflatex failed (font issue), trying xelatex...`);
+      try {
+        await convertFile(inputFile, outputFile, 'xelatex');
+        return;
+      } catch (fallbackErr) {
+        console.error(`\nConversion failed with both engines:`);
+        console.error(fallbackErr.message);
+        process.exit(1);
+      }
+    }
+    console.error(`\nConversion failed:`);
+    console.error(err.message);
+    if (err.message.includes('Command failed')) {
+      console.error('\nTip: Your TeX file may have errors or missing packages.');
+      console.error('  Check the file compiles with a LaTeX editor first.');
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/find-latex.js

@@ -0,0 +1,79 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const os = require('os');
+
+const PLATFORM = os.platform();
+const TINYTEX_DIR = path.join(__dirname, '.tinytex');
+
+function findSystemLaTeX() {
+  try {
+    const pdflatexPath = execSync('which pdflatex || where pdflatex', { 
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore']
+    }).trim();
+    
+    if (pdflatexPath) {
+      return path.dirname(pdflatexPath);
+    }
+  } catch (e) {
+    return null;
+  }
+}
+
+function findTinyTeX() {
+  let binPath;
+  
+  if (PLATFORM === 'win32') {
+    binPath = path.join(TINYTEX_DIR, 'bin', 'windows');
+  } else if (PLATFORM === 'darwin') {
+    binPath = path.join(TINYTEX_DIR, 'bin', 'universal-darwin');
+  } else {
+    binPath = path.join(TINYTEX_DIR, 'bin', 'x86_64-linux');
+  }
+  
+  const pdflatexPath = path.join(binPath, PLATFORM === 'win32' ? 'pdflatex.exe' : 'pdflatex');
+  
+  if (fs.existsSync(pdflatexPath)) {
+    return binPath;
+  }
+  
+  return null;
+}
+
+function getLaTeXPath() {
+  const systemPath = findSystemLaTeX();
+  if (systemPath) {
+    return { path: systemPath, type: 'system' };
+  }
+  
+  const tinytexPath = findTinyTeX();
+  if (tinytexPath) {
+    return { path: tinytexPath, type: 'tinytex' };
+  }
+  
+  return null;
+}
+
+function hasLaTeX() {
+  return getLaTeXPath() !== null;
+}
+
+function getEnginePath(engine = 'pdflatex') {
+  const latexInfo = getLaTeXPath();
+  
+  if (!latexInfo) {
+    return null;
+  }
+  
+  const engineName = PLATFORM === 'win32' ? `${engine}.exe` : engine;
+  return path.join(latexInfo.path, engineName);
+}
+
+module.exports = {
+  getLaTeXPath,
+  hasLaTeX,
+  getEnginePath,
+  findTinyTeX,
+  TINYTEX_DIR
+};

package/install-latex.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+const tar = require('tar');
+const os = require('os');
+
+const PLATFORM = os.platform();
+const INSTALL_DIR = path.join(__dirname, '.tinytex');
+
+function log(message) {
+  console.log(`[tex2pdf-setup] ${message}`);
+}
+
+function checkExistingLaTeX() {
+  try {
+    execSync('pdflatex --version', { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function checkTinyTeXInstalled() {
+  const tinytexBin = getTinyTeXBinPath();
+  if (!tinytexBin) return false;
+  const xelatexPath = path.join(tinytexBin, PLATFORM === 'win32' ? 'xelatex.exe' : 'xelatex');
+  return fs.existsSync(xelatexPath);
+}
+
+function getTinyTeXBinPath() {
+  if (PLATFORM === 'win32') {
+    return path.join(INSTALL_DIR, 'bin', 'windows');
+  } else if (PLATFORM === 'darwin') {
+    return path.join(INSTALL_DIR, 'bin', 'universal-darwin');
+  } else {
+    return path.join(INSTALL_DIR, 'bin', 'x86_64-linux');
+  }
+}
+
+function fixTinyTeXSymlinks() {
+  const binPath = getTinyTeXBinPath();
+  if (!fs.existsSync(binPath)) {
+    return false;
+  }
+
+  let fixedCount = 0;
+
+  const files = fs.readdirSync(binPath);
+  for (const file of files) {
+    const filePath = path.join(binPath, file);
+    try {
+      const stats = fs.lstatSync(filePath);
+      if (stats.isSymbolicLink()) {
+        try {
+          fs.accessSync(filePath, fs.constants.F_OK);
+        } catch (e) {
+          fs.unlinkSync(filePath);
+          fixedCount++;
+        }
+      }
+    } catch (e) {
+      try {
+        fs.unlinkSync(filePath);
+        fixedCount++;
+      } catch (e2) {}
+    }
+  }
+
+  if (fixedCount > 0) {
+    log(`Fixed ${fixedCount} broken symlinks`);
+  }
+
+  const symlinks = [
+    { from: 'pdftex', to: 'pdflatex' },
+    { from: 'tex', to: 'latex' },
+    { from: 'luatex', to: 'lualatex' },
+    { from: 'xetex', to: 'xelatex' },
+  ];
+
+  for (const { from, to } of symlinks) {
+    const fromPath = path.join(binPath, PLATFORM === 'win32' ? `${from}.exe` : from);
+    const toPath = path.join(binPath, PLATFORM === 'win32' ? `${to}.exe` : to);
+
+    if (fs.existsSync(fromPath) && !fs.existsSync(toPath)) {
+      try {
+        fs.symlinkSync(fromPath, toPath);
+      } catch (e) {
+        try {
+          fs.copyFileSync(fromPath, toPath);
+        } catch (e2) {}
+      }
+    }
+  }
+
+  return true;
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    log(`Downloading TinyTeX (~200MB)...`);
+    const file = fs.createWriteStream(dest);
+
+    https.get(url, { redirect: 'follow' }, (response) => {
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        file.close();
+        fs.unlinkSync(dest);
+        downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`Download failed with status ${response.statusCode}`));
+        return;
+      }
+
+      const totalSize = parseInt(response.headers['content-length'], 10);
+      let downloadedSize = 0;
+      let lastPercent = 0;
+
+      response.on('data', (chunk) => {
+        downloadedSize += chunk.length;
+        if (totalSize) {
+          const percent = Math.floor((downloadedSize / totalSize) * 100);
+          if (percent > lastPercent && percent % 10 === 0) {
+            log(`Download progress: ${percent}%`);
+            lastPercent = percent;
+          }
+        }
+      });
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+
+      file.on('error', (err) => {
+        fs.unlinkSync(dest);
+        reject(err);
+      });
+    }).on('error', (err) => {
+      fs.unlinkSync(dest);
+      reject(err);
+    });
+  });
+}
+
+async function installTinyTeXUnix() {
+  // Use full TinyTeX (not TinyTeX-1) which includes format files
+  const url = PLATFORM === 'darwin'
+    ? 'https://github.com/rstudio/tinytex-releases/releases/download/daily/TinyTeX.tgz'
+    : 'https://github.com/rstudio/tinytex-releases/releases/download/daily/TinyTeX.tar.gz';
+  const tarPath = path.join(__dirname, `tinytex-${Date.now()}.tar.gz`);
+
+  try {
+    await downloadFile(url, tarPath);
+
+    log('Extracting TinyTeX...');
+    if (!fs.existsSync(INSTALL_DIR)) {
+      fs.mkdirSync(INSTALL_DIR, { recursive: true });
+    }
+
+    await tar.extract({
+      file: tarPath,
+      cwd: INSTALL_DIR,
+      strip: 1
+    });
+
+    fs.unlinkSync(tarPath);
+    fixTinyTeXSymlinks();
+
+    return true;
+  } catch (error) {
+    log(`Error installing TinyTeX: ${error.message}`);
+    if (fs.existsSync(tarPath)) {
+      fs.unlinkSync(tarPath);
+    }
+    return false;
+  }
+}
+
+async function installTinyTeXWindows() {
+  log('Windows installation requires manual steps or Chocolatey');
+  log('Please install TinyTeX using one of these methods:');
+  log('  1. choco install tinytex');
+  log('  2. scoop install tinytex');
+  log('  3. Download from https://github.com/rstudio/tinytex-releases');
+  log('');
+  log('Or use WSL (Windows Subsystem for Linux) for automatic installation');
+  return false;
+}
+
+async function installTinyTeX() {
+  log('LaTeX not found. Installing TinyTeX (this may take a few minutes)...');
+
+  if (PLATFORM === 'win32') {
+    return await installTinyTeXWindows();
+  } else {
+    return await installTinyTeXUnix();
+  }
+}
+
+async function main() {
+  const isPostinstall = process.env.npm_lifecycle_event === 'postinstall';
+
+  log('Checking for LaTeX installation...');
+
+  if (checkExistingLaTeX()) {
+    log('Found existing LaTeX installation. Skipping TinyTeX installation.');
+    process.exit(0);
+  }
+
+  if (checkTinyTeXInstalled()) {
+    fixTinyTeXSymlinks();
+    log('TinyTeX is already installed and ready.');
+    process.exit(0);
+  }
+
+  const success = await installTinyTeX();
+
+  if (success) {
+    log('TinyTeX installed successfully!');
+    log(`Location: ${INSTALL_DIR}`);
+    process.exit(0);
+  } else {
+    log('Failed to install TinyTeX automatically.');
+    log('LaTeX will be installed on first use of tex2pdf command.');
+    log('Or install manually from https://tug.org/texlive/ or https://miktex.org/');
+
+    if (isPostinstall) {
+      log('Note: This is non-fatal. npm install will continue.');
+      process.exit(0);
+    } else {
+      process.exit(1);
+    }
+  }
+}
+
+module.exports = { fixTinyTeXSymlinks, getTinyTeXBinPath };
+
+if (require.main === module) {
+  main();
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "tex2pdf-cli",
+  "version": "1.0.0",
+  "description": "Convert TeX files to PDF with zero setup - auto-installs LaTeX if needed",
+  "main": "cli.js",
+  "bin": {
+    "tex2pdf": "./cli.js"
+  },
+  "files": [
+    "cli.js",
+    "find-latex.js",
+    "install-latex.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node install-latex.js || true",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "tex",
+    "latex",
+    "pdf",
+    "converter",
+    "cli",
+    "npx",
+    "tinytex",
+    "zero-setup"
+  ],
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/tex2pdf-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/tex2pdf-cli/issues"
+  },
+  "homepage": "https://github.com/yourusername/tex2pdf-cli#readme",
+  "dependencies": {
+    "node-latex": "^3.1.0",
+    "tar": "^7.0.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}