@nodepisss/vpn_tool 1.0.0

package/README.md

@@ -0,0 +1,10 @@
+# vpn_tool
+
+Command-line client for the VPN Control API.
+
+## Installation
+
+Install globally:
+
+```bash
+npm install -g vpn_tool

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@nodepisss/vpn_tool",
+  "version": "1.0.0",
+  "description": "Command-line client for the VPN Control API",
+  "type": "module",
+  "bin": {
+    "vpn-tool": "./vpn-tool.js"
+  },
+  "main": "./vpn-tool.js",
+  "scripts": {
+    "start": "node ./vpn-tool.js",
+    "test": "node ./vpn-tool.js --help"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hb044082-alt/vpn_tool.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hb044082-alt/vpn_tool/issues"
+  },
+  "homepage": "https://github.com/hb044082-alt/vpn_tool#readme",
+  "dependencies": {
+    "axios": "^1.8.0",
+    "commander": "^14.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}

package/vpn-tool.js

@@ -0,0 +1,871 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import crypto from 'node:crypto';
+import axios from 'axios';
+import { Command } from 'commander';
+
+const API_BASE = 'https://vpncontrol-b2m4cn5q.manus.space';
+const APP_NAME = 'vpn-tool';
+const VERSION = '1.0.0';
+
+const AUTH_FILE = 'auth.json';
+const LOCK_FILE = 'pin.lock';
+
+const MAX_PIN_ATTEMPTS = 5;
+const LOCKOUT_SECONDS = 8 * 60 * 60;
+
+function fail(message, code = 1) {
+  process.stderr.write(`error: ${message}\n`);
+  process.exit(code);
+}
+
+function getAppDir(dir) {
+  if (!dir || dir.trim() === '') {
+    fail(
+      'missing required option: --dir <path>\n' +
+      'Example: vpn-tool --dir /path/to/data auth register'
+    );
+  }
+
+  return path.resolve(dir);
+}
+
+function validateExistingDir(dir) {
+  try {
+    const stats = fs.statSync(dir);
+
+    if (!stats.isDirectory()) {
+      fail(`path exists but is not a directory: ${dir}`);
+    }
+  } catch (err) {
+    if (err?.code === 'ENOENT') {
+      process.stderr.write(
+        `Directory not found: ${dir} (ENOENT)\n`
+      );
+      process.exit(1);
+    }
+
+    fail(`unable to access directory: ${dir}`);
+  }
+}
+
+function getExistingDir(options) {
+  const dir = getAppDir(options.dir);
+  validateExistingDir(dir);
+  return dir;
+}
+
+function authFile(dir) {
+  return path.join(dir, AUTH_FILE);
+}
+
+function lockFile(dir) {
+  return path.join(dir, LOCK_FILE);
+}
+
+function output(data, json) {
+  if (json || typeof data === 'object') {
+    process.stdout.write(
+      JSON.stringify(data, null, 2) + '\n'
+    );
+  } else {
+    process.stdout.write(String(data) + '\n');
+  }
+}
+
+function prompt(queryText) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(queryText, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function promptPin(queryText) {
+  return prompt(queryText);
+}
+
+function readJsonFile(file) {
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+
+  try {
+    const raw = fs.readFileSync(file, 'utf8');
+
+    if (!raw.trim()) {
+      return null;
+    }
+
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonFile(file, data) {
+  const dir = path.dirname(file);
+
+  validateExistingDir(dir);
+
+  try {
+    fs.writeFileSync(
+      file,
+      JSON.stringify(data, null, 2) + '\n',
+      {
+        encoding: 'utf8',
+        mode: 0o600
+      }
+    );
+
+    try {
+      fs.chmodSync(file, 0o600);
+    } catch {
+      // Ignore unsupported chmod.
+    }
+  } catch {
+    fail(`unable to write ${file}`);
+  }
+}
+
+function checkLockout(dir) {
+  const lock = readJsonFile(lockFile(dir));
+
+  if (!lock) {
+    return;
+  }
+
+  const lockedUntil = Number(lock.locked_until || 0);
+
+  if (lockedUntil <= 0) {
+    return;
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+
+  if (now < lockedUntil) {
+    const remaining = lockedUntil - now;
+    const hours = Math.floor(remaining / 3600);
+    const minutes = Math.floor((remaining % 3600) / 60);
+
+    fail(
+      `pin.lockout: too many failed attempts. ` +
+      `Try again in ${hours} hours` +
+      `${minutes > 0 ? ` ${minutes} minutes` : ''}.`
+    );
+  }
+
+  const file = lockFile(dir);
+
+  if (fs.existsSync(file)) {
+    fs.unlinkSync(file);
+  }
+}
+
+function failedPin(dir) {
+  const file = lockFile(dir);
+
+  const lock = readJsonFile(file) || {
+    attempts: 0,
+    locked_until: 0
+  };
+
+  const attempts = Number(lock.attempts || 0) + 1;
+  const now = Math.floor(Date.now() / 1000);
+
+  if (attempts >= MAX_PIN_ATTEMPTS) {
+    writeJsonFile(file, {
+      attempts,
+      locked_until: now + LOCKOUT_SECONDS,
+      locked_at: new Date().toISOString(),
+      lockout_seconds: LOCKOUT_SECONDS
+    });
+
+    fail(
+      'pin.lockout: too many failed attempts. ' +
+      'Try again in 8 hours.'
+    );
+  }
+
+  writeJsonFile(file, {
+    attempts,
+    locked_until: 0
+  });
+
+  fail('invalid PIN');
+}
+
+function loadAuth(dir) {
+  return readJsonFile(authFile(dir));
+}
+
+function loggedIn(dir) {
+  const auth = loadAuth(dir);
+
+  return (
+    auth !== null &&
+    Boolean(auth.logged_in)
+  );
+}
+
+function requireLogin(dir) {
+  if (!loggedIn(dir)) {
+    fail(
+      'not logged in. ' +
+      'Try: vpn-tool --dir <path> auth login'
+    );
+  }
+}
+
+async function registerPin(dir, replace = false) {
+  validateExistingDir(dir);
+
+  const authData = loadAuth(dir);
+
+  if (authData && !replace) {
+    fail(
+      'PIN already registered. ' +
+      'Use "auth reset" to change it.'
+    );
+  }
+
+  while (true) {
+    const pin = await promptPin('Enter new PIN: ');
+
+    if (pin.length < 4) {
+      process.stderr.write(
+        'error: PIN must contain at least 4 characters.\n'
+      );
+      continue;
+    }
+
+    const confirm = await promptPin('Confirm new PIN: ');
+
+    if (pin !== confirm) {
+      process.stderr.write(
+        'error: PINs do not match.\n'
+      );
+      continue;
+    }
+
+    const existing = loadAuth(dir);
+
+    const pinHash = crypto
+      .createHash('sha256')
+      .update(pin)
+      .digest('hex');
+
+    const newAuth = {
+      pin_hash: pinHash,
+      logged_in: false,
+      created_at:
+        existing?.created_at ||
+        new Date().toISOString(),
+      updated_at: new Date().toISOString()
+    };
+
+    writeJsonFile(authFile(dir), newAuth);
+
+    const lockF = lockFile(dir);
+
+    if (fs.existsSync(lockF)) {
+      fs.unlinkSync(lockF);
+    }
+
+    return;
+  }
+}
+
+async function verifyPin(dir, pin) {
+  checkLockout(dir);
+
+  const auth = loadAuth(dir);
+
+  if (!auth || !auth.pin_hash) {
+    fail(
+      'no PIN registered. ' +
+      'Try: vpn-tool --dir <path> auth register'
+    );
+  }
+
+  const pinHash = crypto
+    .createHash('sha256')
+    .update(pin)
+    .digest('hex');
+
+  if (pinHash !== auth.pin_hash) {
+    failedPin(dir);
+  }
+
+  const lockF = lockFile(dir);
+
+  if (fs.existsSync(lockF)) {
+    fs.unlinkSync(lockF);
+  }
+
+  return true;
+}
+
+/*
+ * Axios API client.
+ */
+const api = axios.create({
+  baseURL: API_BASE,
+  timeout: 30000,
+  headers: {
+    Accept: 'application/json'
+  }
+});
+
+async function apiRequest(method, endpoint, body = null) {
+  try {
+    const response = await api.request({
+      method: method.toLowerCase(),
+      url: endpoint,
+      ...(body !== null ? { data: body } : {})
+    });
+
+    return response.data;
+  } catch (err) {
+    if (err.response) {
+      const data = err.response.data;
+
+      let message = `HTTP ${err.response.status}`;
+
+      if (
+        typeof data === 'object' &&
+        data !== null
+      ) {
+        message =
+          data.error ||
+          data.message ||
+          message;
+
+        if (data.details) {
+          message += `: ${data.details}`;
+        }
+      } else if (typeof data === 'string' && data.trim()) {
+        message = data;
+      }
+
+      fail(message);
+    }
+
+    if (err.code === 'ECONNABORTED') {
+      fail('API request timed out');
+    }
+
+    fail(
+      `API request failed: ${err.message}`
+    );
+  }
+}
+
+const program = new Command();
+
+program
+  .name(APP_NAME)
+  .version(VERSION)
+  .option('--json', 'JSON output')
+  .option('--output <format>', 'Output format')
+  .requiredOption(
+    '--dir <path>',
+    'Existing local data directory'
+  );
+
+function isJson(options, globalOpts) {
+  return (
+    options.json ||
+    globalOpts.json ||
+    options.output === 'json' ||
+    globalOpts.output === 'json'
+  );
+}
+
+program
+  .command('countries')
+  .description('List supported countries')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    requireLogin(dir);
+
+    const data = await apiRequest(
+      'GET',
+      '/api/countries'
+    );
+
+    output(
+      data,
+      isJson(cmd.opts(), globalOpts)
+    );
+  });
+
+program
+  .command('connect')
+  .description('Connect to country')
+  .option(
+    '--country <code2>',
+    'Country code'
+  )
+  .action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    requireLogin(dir);
+
+    let country = opts.country;
+
+    if (!country || country.trim() === '') {
+      country = await prompt(
+        'Enter country code (example: DE or JP): '
+      );
+    }
+
+    country = country.toUpperCase().trim();
+
+    if (!/^[A-Z]{2}$/.test(country)) {
+      fail(
+        'countryCode must be a two-letter code such as DE or JP'
+      );
+    }
+
+    const data = await apiRequest(
+      'POST',
+      '/api/vpn/connect',
+      {
+        countryCode: country
+      }
+    );
+
+    output(
+      data,
+      isJson(opts, globalOpts)
+    );
+  });
+
+program
+  .command('status')
+  .description('Show VPN status')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    requireLogin(dir);
+
+    const data = await apiRequest(
+      'GET',
+      '/api/vpn/status'
+    );
+
+    output(
+      data,
+      isJson(cmd.opts(), globalOpts)
+    );
+  });
+
+program
+  .command('disconnect')
+  .description('Disconnect VPN')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    requireLogin(dir);
+
+    const data = await apiRequest(
+      'POST',
+      '/api/vpn/disconnect'
+    );
+
+    output(
+      data,
+      isJson(cmd.opts(), globalOpts)
+    );
+  });
+
+program
+  .command('ip')
+  .description('Return assigned/generated IPs')
+  .option(
+    '--count <number>',
+    'Number of IPs',
+    '10'
+  )
+  .action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    requireLogin(dir);
+
+    const count = opts.count;
+
+    if (
+      !/^\d+$/.test(count) ||
+      parseInt(count, 10) < 1
+    ) {
+      fail('--count must be a positive integer');
+    }
+
+    const data = await apiRequest(
+      'GET',
+      `/api/vpn/ip?count=${encodeURIComponent(count)}`
+    );
+
+    output(
+      data,
+      isJson(opts, globalOpts)
+    );
+  });
+
+program
+  .command('ips')
+  .description('Generate simulated VPN IPs')
+  .option(
+    '--count <number>',
+    'Number of IPs',
+    '10'
+  )
+  .action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    requireLogin(dir);
+
+    const count = opts.count;
+
+    if (
+      !/^\d+$/.test(count) ||
+      parseInt(count, 10) < 1
+    ) {
+      fail('--count must be a positive integer');
+    }
+
+    const data = await apiRequest(
+      'GET',
+      `/api/vpn/ips?count=${encodeURIComponent(count)}`
+    );
+
+    output(
+      data,
+      isJson(opts, globalOpts)
+    );
+  });
+
+program
+  .command('test')
+  .description('Test sleep endpoint')
+  .option(
+    '--ms <number>',
+    'Milliseconds',
+    '1000'
+  )
+  .action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    requireLogin(dir);
+
+    const ms = opts.ms;
+
+    if (
+      !/^\d+$/.test(ms) ||
+      parseInt(ms, 10) < 0
+    ) {
+      fail('--ms must be a non-negative integer');
+    }
+
+    const data = await apiRequest(
+      'GET',
+      `/api/test/sleep?ms=${encodeURIComponent(ms)}`
+    );
+
+    output(
+      data,
+      isJson(opts, globalOpts)
+    );
+  });
+
+const auth = program
+  .command('auth')
+  .description('Authentication management');
+
+auth
+  .command('register')
+  .description('Register PIN')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    await registerPin(dir);
+
+    const data = {
+      success: true,
+      registered: true,
+      logged_in: false
+    };
+
+    if (isJson(cmd.opts(), globalOpts)) {
+      output(data, true);
+    } else {
+      process.stdout.write(
+        'PIN registered successfully.\n'
+      );
+    }
+  });
+
+auth
+  .command('login')
+  .description('Login')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    checkLockout(dir);
+
+    if (!readJsonFile(authFile(dir))) {
+      fail(
+        'no PIN registered. ' +
+        'Try: vpn-tool --dir <path> auth register'
+      );
+    }
+
+    const pin = await promptPin('Enter PIN: ');
+
+    await verifyPin(dir, pin);
+
+    const authData = loadAuth(dir);
+
+    authData.logged_in = true;
+    authData.last_login = new Date().toISOString();
+
+    writeJsonFile(
+      authFile(dir),
+      authData
+    );
+
+    const data = {
+      success: true,
+      logged_in: true
+    };
+
+    if (isJson(cmd.opts(), globalOpts)) {
+      output(data, true);
+    } else {
+      process.stdout.write(
+        'Login successful.\n'
+      );
+    }
+  });
+
+auth
+  .command('status')
+  .description('Authentication status')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    checkLockout(dir);
+
+    const authData = loadAuth(dir);
+    const lock = readJsonFile(lockFile(dir));
+
+    const data = {
+      registered: authData !== null,
+      logged_in: loggedIn(dir),
+      directory: dir,
+      lockout: {
+        locked: Boolean(
+          lock &&
+          lock.locked_until &&
+          Number(lock.locked_until) >
+            Math.floor(Date.now() / 1000)
+        ),
+        attempts: Number(
+          lock?.attempts || 0
+        )
+      }
+    };
+
+    if (authData) {
+      data.created_at =
+        authData.created_at || null;
+
+      data.last_login =
+        authData.last_login || null;
+    }
+
+    output(
+      data,
+      isJson(cmd.opts(), globalOpts)
+    );
+  });
+
+auth
+  .command('logout')
+  .description('Logout')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    if (!readJsonFile(authFile(dir))) {
+      fail('not logged in');
+    }
+
+    const authData = loadAuth(dir);
+
+    authData.logged_in = false;
+    authData.last_logout = new Date().toISOString();
+
+    writeJsonFile(
+      authFile(dir),
+      authData
+    );
+
+    const data = {
+      success: true,
+      logged_in: false
+    };
+
+    if (isJson(cmd.opts(), globalOpts)) {
+      output(data, true);
+    } else {
+      process.stdout.write(
+        'Logged out successfully.\n'
+      );
+    }
+  });
+
+auth
+  .command('reset')
+  .description('Change PIN')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    checkLockout(dir);
+
+    if (!readJsonFile(authFile(dir))) {
+      fail(
+        'no PIN registered. ' +
+        'Try: vpn-tool --dir <path> auth register'
+      );
+    }
+
+    const oldPin = await promptPin(
+      'Enter current PIN: '
+    );
+
+    await verifyPin(dir, oldPin);
+
+    await registerPin(dir, true);
+
+    const data = {
+      success: true,
+      message: 'PIN reset successfully'
+    };
+
+    if (isJson(cmd.opts(), globalOpts)) {
+      output(data, true);
+    } else {
+      process.stdout.write(
+        'PIN reset successfully.\n'
+      );
+    }
+  });
+
+auth
+  .command('remove')
+  .description('Remove PIN')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    checkLockout(dir);
+
+    if (!readJsonFile(authFile(dir))) {
+      fail('no stored PIN found');
+    }
+
+    const pin = await promptPin(
+      'Enter PIN to confirm removal: '
+    );
+
+    await verifyPin(dir, pin);
+
+    const af = authFile(dir);
+
+    if (fs.existsSync(af)) {
+      fs.unlinkSync(af);
+    }
+
+    const lf = lockFile(dir);
+
+    if (fs.existsSync(lf)) {
+      fs.unlinkSync(lf);
+    }
+
+    const data = {
+      success: true,
+      registered: false
+    };
+
+    if (isJson(cmd.opts(), globalOpts)) {
+      output(data, true);
+    } else {
+      process.stdout.write(
+        'Stored PIN removed.\n'
+      );
+    }
+  });
+
+auth
+  .command('list')
+  .description('List stored PIN metadata')
+  .action(async (_, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const dir = getExistingDir(globalOpts);
+
+    const authData = loadAuth(dir);
+
+    if (!authData) {
+      output(
+        {
+          stored: false,
+          pins: []
+        },
+        isJson(cmd.opts(), globalOpts)
+      );
+
+      return;
+    }
+
+    output(
+      {
+        stored: true,
+        pins: [
+          {
+            created_at:
+              authData.created_at || null,
+            logged_in:
+              Boolean(authData.logged_in),
+            last_login:
+              authData.last_login || null
+          }
+        ]
+      },
+      isJson(cmd.opts(), globalOpts)
+    );
+  });
+
+program.parse(process.argv);