@nordbyte/nordrelay 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nordbyte/nordrelay",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Remote control plane for coding agents across messaging channels.",
   "type": "module",
   "author": "Ricardo",
@@ -30,6 +30,7 @@
     "dist/",
     "plugins/",
     "launchd/",
+    "CHANGELOG.md",
     ".env.example",
     "Dockerfile",
     "docker-compose.yml"
@@ -41,6 +42,8 @@
     "foreground": "node plugins/nordrelay/scripts/nordrelay.mjs foreground",
     "prepack": "npm run build",
     "prepublishOnly": "npm run check && npm test && npm run build",
+    "security:audit": "npm audit --audit-level=high",
+    "sbom": "npm sbom --json > sbom.json",
     "status": "node plugins/nordrelay/scripts/nordrelay.mjs status",
     "start": "node plugins/nordrelay/scripts/nordrelay.mjs start",
     "stop": "node plugins/nordrelay/scripts/nordrelay.mjs stop",

package/plugins/nordrelay/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nordrelay",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Run a remote-control bridge for coding agents. The current adapter connects Codex sessions to Telegram with streaming replies, multi-session controls, attachments, voice input, model selection, thread browsing, and handback.",
   "author": {
     "name": "Ricardo",

package/plugins/nordrelay/scripts/nordrelay.mjs

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import fsp from "node:fs/promises";
+import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import readline from "node:readline/promises";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
-const VERSION = "0.2.1";
+const VERSION = "0.3.0";
+const require = createRequire(import.meta.url);
 const APP_NAME = "nordrelay";
 const SCRIPT_PATH = fileURLToPath(import.meta.url);
 const PLUGIN_ROOT = path.resolve(path.dirname(SCRIPT_PATH), "..");
@@ -31,12 +34,23 @@ function parseArgs(argv) {
     rawFlags: copy,
     home: process.env.NORDRELAY_HOME || DEFAULT_HOME,
     dropPendingUpdates: !envFlag("NORDRELAY_KEEP_PENDING_UPDATES"),
+    force: false,
+    host: process.env.NORDRELAY_DASHBOARD_HOST || "127.0.0.1",
+    port: Number.parseInt(process.env.NORDRELAY_DASHBOARD_PORT || "31878", 10),
   };
 
   for (let i = 0; i < copy.length; i += 1) {
     const arg = copy[i];
     if (arg === "--home") options.home = requireValue(copy, ++i, arg);
     else if (arg === "--keep-pending-updates") options.dropPendingUpdates = false;
+    else if (arg === "--force") options.force = true;
+    else if (arg === "--host") options.host = requireValue(copy, ++i, arg);
+    else if (arg === "--port") options.port = Number.parseInt(requireValue(copy, ++i, arg), 10);
+    else if (arg === "--token") options.telegramBotToken = requireValue(copy, ++i, arg);
+    else if (arg === "--admin-id") options.telegramAdminUserIds = requireValue(copy, ++i, arg);
+    else if (arg === "--state-backend") options.stateBackend = requireValue(copy, ++i, arg);
+    else if (arg === "--enable-pi") options.enablePi = true;
+    else if (arg === "--disable-codex") options.disableCodex = true;
   }
 
   options.pidFile = path.join(options.home, "nordrelay.pid");
@@ -254,6 +268,124 @@ async function commandStatus(options) {
   if (state.error) console.log(`Error: ${state.error}`);
 }
 
+async function commandInit(options) {
+  await mkdirp(options.home);
+  const envPath = path.join(options.home, "nordrelay.env");
+  if (fs.existsSync(envPath) && !options.force) {
+    console.log(`Config already exists: ${envPath}`);
+    console.log("Run with --force to overwrite.");
+    return;
+  }
+
+  const rl = process.stdin.isTTY
+    ? readline.createInterface({ input: process.stdin, output: process.stdout })
+    : null;
+  try {
+    const telegramBotToken = options.telegramBotToken ||
+      process.env.TELEGRAM_BOT_TOKEN ||
+      await ask(rl, "Telegram bot token", "");
+    const telegramAdminUserIds = options.telegramAdminUserIds ||
+      process.env.TELEGRAM_ADMIN_USER_IDS ||
+      await ask(rl, "Telegram admin user id", "");
+    const enableCodex = options.disableCodex ? "false" : await askChoice(rl, "Enable Codex", "true");
+    const enablePi = options.enablePi ? "true" : await askChoice(rl, "Enable Pi", "false");
+    const stateBackend = options.stateBackend || await askChoice(rl, "State backend (json/sqlite)", "json");
+
+    if (!telegramBotToken) throw new Error("Telegram bot token is required.");
+    if (!telegramAdminUserIds) throw new Error("Telegram admin user id is required.");
+    if (enableCodex !== "true" && enablePi !== "true") throw new Error("At least one agent must be enabled.");
+
+    const lines = [
+      "# NordRelay local runtime config.",
+      "# Keep this file private; it contains bot credentials.",
+      `TELEGRAM_BOT_TOKEN=${telegramBotToken}`,
+      `TELEGRAM_ADMIN_USER_IDS=${telegramAdminUserIds}`,
+      "TELEGRAM_ALLOW_ANY_CHAT=false",
+      `NORDRELAY_CODEX_ENABLED=${enableCodex}`,
+      `NORDRELAY_PI_ENABLED=${enablePi}`,
+      `NORDRELAY_DEFAULT_AGENT=${enableCodex === "true" ? "codex" : "pi"}`,
+      `NORDRELAY_STATE_BACKEND=${stateBackend === "sqlite" ? "sqlite" : "json"}`,
+      "TELEGRAM_TRANSPORT=polling",
+      "TELEGRAM_AUTO_SEND_ARTIFACTS=false",
+      "",
+    ];
+
+    await fsp.writeFile(envPath, lines.join("\n"), { mode: 0o600 });
+    await fsp.chmod(envPath, 0o600).catch(() => {});
+    console.log(`Wrote ${envPath}`);
+    console.log("Run `nordrelay doctor` to validate the setup.");
+  } finally {
+    rl?.close();
+  }
+}
+
+async function commandDoctor(options) {
+  await mkdirp(options.home);
+  loadEnvFiles(options.home);
+  const checks = [];
+  checks.push(check("Node.js >= 22", Number.parseInt(process.versions.node.split(".")[0], 10) >= 22, process.version));
+  checks.push(check("Telegram bot token", Boolean(process.env.TELEGRAM_BOT_TOKEN), process.env.TELEGRAM_BOT_TOKEN ? "configured" : "missing"));
+  checks.push(check("Telegram admin ids", Boolean(process.env.TELEGRAM_ADMIN_USER_IDS), process.env.TELEGRAM_ADMIN_USER_IDS ? "configured" : "missing"));
+  checks.push(check("Private by default", process.env.TELEGRAM_ALLOW_ANY_CHAT !== "true", "TELEGRAM_ALLOW_ANY_CHAT is not true"));
+  checks.push(check("Codex enabled flag", process.env.NORDRELAY_CODEX_ENABLED !== "false", `NORDRELAY_CODEX_ENABLED=${process.env.NORDRELAY_CODEX_ENABLED ?? "true"}`));
+  checks.push(check("Pi enabled flag", process.env.NORDRELAY_PI_ENABLED === "true" || process.env.NORDRELAY_PI_ENABLED === undefined, `NORDRELAY_PI_ENABLED=${process.env.NORDRELAY_PI_ENABLED ?? "false"}`, process.env.NORDRELAY_PI_ENABLED === "true" ? "pass" : "warn"));
+  checks.push(check("Codex CLI", Boolean(findExecutable(process.env.CODEX_CLI_PATH || "codex")), process.env.CODEX_CLI_PATH || findExecutable("codex") || "not found", process.env.NORDRELAY_CODEX_ENABLED === "false" ? "warn" : "fail"));
+  checks.push(check("Pi CLI", Boolean(findExecutable(process.env.PI_CLI_PATH || "pi")), process.env.PI_CLI_PATH || findExecutable("pi") || "not found", process.env.NORDRELAY_PI_ENABLED === "true" ? "fail" : "warn"));
+  checks.push(check("ffmpeg", Boolean(findExecutable("ffmpeg")), findExecutable("ffmpeg") || "not found", "warn"));
+  checks.push(check("State backend", validateStateBackend(), `NORDRELAY_STATE_BACKEND=${process.env.NORDRELAY_STATE_BACKEND ?? "json"}`));
+  checks.push(check("Runtime entry", Boolean(await resolveRuntimeEntry()), RUNTIME_ROOT));
+
+  for (const item of checks) {
+    console.log(`${item.icon} ${item.name}: ${item.detail}`);
+  }
+
+  const failed = checks.filter((item) => item.status === "fail" && !item.ok);
+  const warned = checks.filter((item) => item.status === "warn" && !item.ok);
+  console.log(`\nSummary: ${failed.length} failed, ${warned.length} warnings.`);
+  if (failed.length > 0) process.exitCode = 1;
+}
+
+async function commandWeb(options) {
+  await mkdirp(options.home);
+  loadEnvFiles(options.home);
+  const host = options.host || "127.0.0.1";
+  const port = Number.isFinite(options.port) ? options.port : 31878;
+  const entry = await resolveWebRuntimeEntry();
+  if (!entry) {
+    throw new Error(`Missing dashboard runtime. Run \`npm install\` and \`npm run build\` in ${RUNTIME_ROOT}.`);
+  }
+
+  const env = {
+    ...process.env,
+    NORDRELAY_HOME: options.home,
+    NORDRELAY_SOURCE_ROOT: RUNTIME_ROOT,
+    NORDRELAY_DASHBOARD_HOST: host,
+    NORDRELAY_DASHBOARD_PORT: String(port),
+  };
+  const child = spawn(entry.command, [...entry.args, "--host", host, "--port", String(port), "--home", options.home], {
+    cwd: RUNTIME_ROOT,
+    env,
+    stdio: "inherit",
+  });
+
+  const forwardSignal = (signal) => {
+    if (isProcessRunning(child.pid)) {
+      child.kill(signal);
+    }
+  };
+  process.once("SIGINT", () => forwardSignal("SIGINT"));
+  process.once("SIGTERM", () => forwardSignal("SIGTERM"));
+
+  const exit = await new Promise((resolve) => {
+    child.once("exit", (code, signal) => resolve({ code, signal }));
+  });
+  if (exit.signal) {
+    process.kill(process.pid, exit.signal);
+    return;
+  }
+  process.exit(exit.code ?? 0);
+}
+
 async function commandForeground(options) {
   await mkdirp(options.home);
   loadEnvFiles(options.home);
@@ -338,6 +470,21 @@ async function resolveRuntimeEntry() {
   return null;
 }
 
+async function resolveWebRuntimeEntry() {
+  const distEntry = path.join(RUNTIME_ROOT, "dist", "web-dashboard.js");
+  if (fs.existsSync(distEntry)) {
+    return { command: process.execPath, args: [distEntry] };
+  }
+
+  const tsEntry = path.join(RUNTIME_ROOT, "src", "web-dashboard.ts");
+  const tsxBin = path.join(RUNTIME_ROOT, "node_modules", ".bin", process.platform === "win32" ? "tsx.cmd" : "tsx");
+  if (fs.existsSync(tsEntry) && fs.existsSync(tsxBin)) {
+    return { command: tsxBin, args: [tsEntry] };
+  }
+
+  return null;
+}
+
 function findRuntimeRoot() {
   const candidates = [
     process.env.NORDRELAY_SOURCE_ROOT,
@@ -366,6 +513,53 @@ function findRuntimeRoot() {
   return DEFAULT_MARKETPLACE_ROOT;
 }
 
+async function ask(rl, label, defaultValue) {
+  if (!rl) return defaultValue;
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  const answer = (await rl.question(`${label}${suffix}: `)).trim();
+  return answer || defaultValue;
+}
+
+async function askChoice(rl, label, defaultValue) {
+  const value = (await ask(rl, label, defaultValue)).toLowerCase();
+  if (["1", "yes", "y", "true", "on"].includes(value)) return "true";
+  if (["0", "no", "n", "false", "off"].includes(value)) return "false";
+  return value || defaultValue;
+}
+
+function check(name, ok, detail, status = "fail") {
+  return {
+    name,
+    ok,
+    detail,
+    status,
+    icon: ok ? "✅" : status === "warn" ? "⚠️" : "❌",
+  };
+}
+
+function findExecutable(command) {
+  if (!command) return null;
+  if (command.includes(path.sep) && fs.existsSync(command)) return command;
+  const paths = (process.env.PATH || "").split(path.delimiter);
+  for (const dir of paths) {
+    const candidate = path.join(dir, command);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function validateStateBackend() {
+  const backend = process.env.NORDRELAY_STATE_BACKEND || "json";
+  if (backend === "json") return true;
+  if (backend !== "sqlite") return false;
+  try {
+    require("better-sqlite3");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -375,6 +569,9 @@ async function main() {
   if (options.command === "start") return commandStart(options);
   if (options.command === "stop") return commandStop(options);
   if (options.command === "status") return commandStatus(options);
+  if (options.command === "init") return commandInit(options);
+  if (options.command === "doctor") return commandDoctor(options);
+  if (options.command === "web" || options.command === "dashboard") return commandWeb(options);
   if (options.command === "restart") {
     await commandStop(options);
     return commandStart(options);
@@ -386,7 +583,7 @@ async function main() {
   }
 
   console.error(`Unknown command: ${options.command}`);
-  console.error("Usage: nordrelay [start|stop|restart|status|foreground]");
+  console.error("Usage: nordrelay [init|doctor|web|start|stop|restart|status|foreground|version]");
   process.exitCode = 2;
 }