@bitcall/webrtc-sip-gateway 0.2.1

package/README.md

@@ -0,0 +1,45 @@
+# @bitcall/webrtc-sip-gateway
+
+Linux-only CLI to install and operate the Bitcall WebRTC-to-SIP gateway.
+
+## Install
+
+```bash
+sudo npm i -g @bitcall/webrtc-sip-gateway@0.2.1
+```
+
+## Main workflow
+
+```bash
+sudo bitcall-gateway init
+sudo bitcall-gateway status
+sudo bitcall-gateway logs -f
+```
+
+## Commands
+
+- `sudo bitcall-gateway init`
+- `sudo bitcall-gateway up`
+- `sudo bitcall-gateway down`
+- `sudo bitcall-gateway restart`
+- `sudo bitcall-gateway status`
+- `sudo bitcall-gateway logs [-f] [service]`
+- `sudo bitcall-gateway cert status`
+- `sudo bitcall-gateway cert renew`
+- `sudo bitcall-gateway cert install --cert /path/cert.pem --key /path/key.pem`
+- `sudo bitcall-gateway update`
+- `sudo bitcall-gateway uninstall`
+
+## Files created by init
+
+- `/opt/bitcall-gateway/.env`
+- `/opt/bitcall-gateway/docker-compose.yml`
+- `/opt/bitcall-gateway/acme-webroot/.well-known/acme-challenge/healthcheck`
+- `/etc/systemd/system/bitcall-gateway.service`
+
+## Publishing npm package
+
+1. Bump version in `cli/package.json`.
+2. Commit the change.
+3. Create tag `vX.Y.Z`.
+4. Push tags; GitHub Actions publishes automatically.

package/bin/bitcall-gateway.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+if (process.getuid && process.getuid() !== 0) {
+  console.error("Error: bitcall-gateway requires root privileges.");
+  console.error(`Run with: sudo bitcall-gateway ${process.argv.slice(2).join(" ")}`);
+  process.exit(1);
+}
+
+require("../src/index").main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/lib/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const path = require("path");
+
+const GATEWAY_DIR = "/opt/bitcall-gateway";
+const SERVICE_NAME = "bitcall-gateway";
+const SERVICE_FILE = `/etc/systemd/system/${SERVICE_NAME}.service`;
+
+module.exports = {
+  GATEWAY_DIR,
+  SERVICE_NAME,
+  SERVICE_FILE,
+  ACME_WEBROOT: path.join(GATEWAY_DIR, "acme-webroot"),
+  SSL_DIR: path.join(GATEWAY_DIR, "ssl"),
+  ENV_PATH: path.join(GATEWAY_DIR, ".env"),
+  COMPOSE_PATH: path.join(GATEWAY_DIR, "docker-compose.yml"),
+  DEFAULT_GATEWAY_IMAGE: "ghcr.io/bitcallio/webrtc-sip-gateway:0.2.1",
+  DEFAULT_PROVIDER_HOST: "sip.example.com",
+  DEFAULT_WEBPHONE_ORIGIN: "*",
+  RENEW_HOOK_PATH: "/etc/letsencrypt/renewal-hooks/deploy/bitcall-gateway.sh",
+};

package/lib/envfile.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const fs = require("fs");
+
+function parseEnv(content) {
+  const data = {};
+
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+
+    const idx = line.indexOf("=");
+    if (idx < 0) {
+      continue;
+    }
+
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1);
+    data[key] = value;
+  }
+
+  return data;
+}
+
+function loadEnvFile(filePath) {
+  return parseEnv(fs.readFileSync(filePath, "utf8"));
+}
+
+function serializeEnv(entries) {
+  return entries
+    .filter((entry) => entry && entry.key)
+    .map((entry) => `${entry.key}=${entry.value === undefined || entry.value === null ? "" : entry.value}`)
+    .join("\n") + "\n";
+}
+
+function writeEnvFile(filePath, entries, mode = 0o600) {
+  const payload = serializeEnv(entries);
+  fs.writeFileSync(filePath, payload, { mode });
+}
+
+module.exports = {
+  parseEnv,
+  loadEnvFile,
+  serializeEnv,
+  writeEnvFile,
+};

package/lib/prompt.js

@@ -0,0 +1,72 @@
+"use strict";
+
+const readline = require("readline");
+const { stdin: input, stdout: output } = require("process");
+
+class Prompter {
+  constructor() {
+    this.rl = readline.createInterface({ input, output });
+  }
+
+  close() {
+    this.rl.close();
+  }
+
+  async askText(label, defaultValue = "", { required = false } = {}) {
+    for (;;) {
+      const suffix = defaultValue !== "" ? ` [${defaultValue}]` : "";
+      const answer = (await this._question(`${label}${suffix}: `)).trim();
+      const value = answer || defaultValue;
+
+      if (required && !value) {
+        console.log("Value is required.");
+        continue;
+      }
+
+      return value;
+    }
+  }
+
+  async askChoice(label, options, defaultIndex = 0) {
+    console.log(label);
+    options.forEach((option, index) => {
+      console.log(`  ${index + 1}. ${option}`);
+    });
+
+    for (;;) {
+      const answer = (await this._question(`Choose [${defaultIndex + 1}]: `)).trim();
+      const selected = answer ? Number.parseInt(answer, 10) : defaultIndex + 1;
+      if (!Number.isNaN(selected) && selected >= 1 && selected <= options.length) {
+        return options[selected - 1];
+      }
+      console.log("Invalid selection.");
+    }
+  }
+
+  async askYesNo(label, defaultYes = true) {
+    const hint = defaultYes ? "[Y/n]" : "[y/N]";
+    for (;;) {
+      const answer = (await this._question(`${label} ${hint}: `)).trim().toLowerCase();
+      if (!answer) {
+        return defaultYes;
+      }
+      if (answer === "y" || answer === "yes") {
+        return true;
+      }
+      if (answer === "n" || answer === "no") {
+        return false;
+      }
+      console.log("Please answer yes or no.");
+    }
+  }
+
+  _question(message) {
+    return new Promise((resolve) => {
+      this.rl.question(message, (answer) => resolve(answer));
+    });
+  }
+}
+
+module.exports = {
+  Prompter,
+};

package/lib/shell.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+
+function run(command, args = [], options = {}) {
+  const {
+    cwd,
+    env,
+    stdio = "pipe",
+    check = true,
+    input,
+    quiet = false,
+  } = options;
+
+  const result = spawnSync(command, args, {
+    cwd,
+    env,
+    input,
+    stdio,
+    encoding: "utf8",
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (check && typeof result.status === "number" && result.status !== 0) {
+    const detail = [result.stdout, result.stderr]
+      .filter(Boolean)
+      .join("\n")
+      .trim();
+    const suffix = detail ? `\n${detail}` : "";
+    throw new Error(`Command failed: ${command} ${args.join(" ")}${suffix}`);
+  }
+
+  if (!quiet && stdio === "inherit") {
+    return result;
+  }
+
+  return result;
+}
+
+function runShell(script, options = {}) {
+  return run("sh", ["-lc", script], options);
+}
+
+function commandExists(command) {
+  const result = spawnSync("sh", ["-lc", `command -v ${command}`], {
+    stdio: "ignore",
+  });
+  return result.status === 0;
+}
+
+function output(command, args = [], options = {}) {
+  const result = run(command, args, { ...options, stdio: "pipe" });
+  return (result.stdout || "").trim();
+}
+
+module.exports = {
+  run,
+  runShell,
+  output,
+  commandExists,
+};

package/lib/system.js

@@ -0,0 +1,149 @@
+"use strict";
+
+const fs = require("fs");
+const { output, run, runShell, commandExists } = require("./shell");
+
+function parseOsRelease() {
+  const info = {};
+  const content = fs.readFileSync("/etc/os-release", "utf8");
+
+  for (const line of content.split(/\r?\n/)) {
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const idx = line.indexOf("=");
+    if (idx < 0) {
+      continue;
+    }
+    const key = line.slice(0, idx);
+    const value = line.slice(idx + 1).replace(/^"|"$/g, "");
+    info[key] = value;
+  }
+
+  return info;
+}
+
+function isSupportedDistro() {
+  const os = parseOsRelease();
+  const id = (os.ID || "").toLowerCase();
+  const version = Number.parseFloat(os.VERSION_ID || "0");
+
+  if (id === "ubuntu") {
+    return version >= 22;
+  }
+
+  if (id === "debian") {
+    return version >= 12;
+  }
+
+  return false;
+}
+
+function detectPublicIp() {
+  const probes = [
+    "https://api.ipify.org",
+    "https://ifconfig.me/ip",
+    "https://icanhazip.com",
+  ];
+
+  for (const url of probes) {
+    const result = run("curl", ["-fsS", "--max-time", "5", url], {
+      check: false,
+      stdio: "pipe",
+    });
+
+    if (result.status === 0) {
+      const ip = (result.stdout || "").trim();
+      if (/^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
+        return ip;
+      }
+    }
+  }
+
+  return "";
+}
+
+function resolveDomainIpv4(domain) {
+  const result = run("getent", ["ahostsv4", domain], { check: false });
+  if (result.status !== 0) {
+    return [];
+  }
+
+  const values = new Set();
+  for (const line of (result.stdout || "").split(/\r?\n/)) {
+    const ip = line.trim().split(/\s+/)[0];
+    if (/^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
+      values.add(ip);
+    }
+  }
+
+  return [...values];
+}
+
+function diskFreeGb(targetPath = "/") {
+  const text = output("df", ["-Pk", targetPath]);
+  const lines = text.split(/\r?\n/).filter(Boolean);
+  if (lines.length < 2) {
+    return 0;
+  }
+
+  const parts = lines[1].trim().split(/\s+/);
+  const availableKb = Number.parseInt(parts[3], 10);
+  return Math.floor(availableKb / 1024 / 1024);
+}
+
+function memoryTotalMb() {
+  const content = fs.readFileSync("/proc/meminfo", "utf8");
+  const match = content.match(/^MemTotal:\s+(\d+)\s+kB$/m);
+  if (!match) {
+    return 0;
+  }
+  return Math.floor(Number.parseInt(match[1], 10) / 1024);
+}
+
+function portInUse(port) {
+  const result = runShell(`ss -H -ltnup | grep -E '[:.]${port}\\b'`, {
+    check: false,
+  });
+
+  return {
+    inUse: result.status === 0,
+    detail: (result.stdout || "").trim(),
+  };
+}
+
+function ensureDockerInstalled() {
+  if (commandExists("docker") && run("docker", ["info"], { check: false }).status === 0) {
+    return;
+  }
+
+  run("apt-get", ["update"], { stdio: "inherit" });
+  run("apt-get", ["install", "-y", "curl", "ca-certificates", "gnupg"], {
+    stdio: "inherit",
+  });
+  runShell("curl -fsSL https://get.docker.com | sh", { stdio: "inherit" });
+  run("systemctl", ["enable", "docker.service"], { stdio: "inherit" });
+  run("systemctl", ["enable", "containerd.service"], { stdio: "inherit" });
+  run("systemctl", ["start", "docker"], { stdio: "inherit" });
+}
+
+function ensureComposePlugin() {
+  if (run("docker", ["compose", "version"], { check: false }).status === 0) {
+    return;
+  }
+
+  run("apt-get", ["update"], { stdio: "inherit" });
+  run("apt-get", ["install", "-y", "docker-compose-plugin"], { stdio: "inherit" });
+}
+
+module.exports = {
+  parseOsRelease,
+  isSupportedDistro,
+  detectPublicIp,
+  resolveDomainIpv4,
+  diskFreeGb,
+  memoryTotalMb,
+  portInUse,
+  ensureDockerInstalled,
+  ensureComposePlugin,
+};

package/lib/template.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const TEMPLATE_DIR = path.resolve(__dirname, "../templates");
+
+function readTemplate(name) {
+  return fs.readFileSync(path.join(TEMPLATE_DIR, name), "utf8");
+}
+
+function renderTemplate(name, values) {
+  let content = readTemplate(name);
+  for (const [key, value] of Object.entries(values)) {
+    const token = `__${key}__`;
+    content = content.split(token).join(String(value === undefined || value === null ? "" : value));
+  }
+  return content;
+}
+
+module.exports = {
+  readTemplate,
+  renderTemplate,
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@bitcall/webrtc-sip-gateway",
+  "version": "0.2.1",
+  "description": "Linux CLI for bootstrapping and managing the Bitcall WebRTC-to-SIP Gateway",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Bitcallio/webrtc-sip-gateway"
+  },
+  "license": "MIT",
+  "bin": {
+    "bitcall-gateway": "bin/bitcall-gateway.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "lib",
+    "templates",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "lint": "node --check src/index.js && node --check bin/bitcall-gateway.js && for f in lib/*.js; do node --check \"$f\"; done",
+    "test": "node test/smoke.test.js",
+    "pack:dry": "npm pack --dry-run"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  }
+}