@nordbyte/nordrelay 0.2.1 → 0.3.1

package/dist/web-state.js

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto";
+import { createDocumentStore } from "./state-backend.js";
+const DEFAULT_CHAT_LIMIT = 300;
+const DEFAULT_ACTIVITY_LIMIT = 1000;
+export class WebChatStore {
+    store;
+    maxMessages;
+    constructor(workspace, backend = "json", maxMessages = DEFAULT_CHAT_LIMIT) {
+        this.store = createDocumentStore({
+            workspace,
+            fileName: "web-chat.json",
+            sqliteKey: "web-chat",
+            backend,
+        });
+        this.maxMessages = maxMessages;
+    }
+    append(input) {
+        const payload = this.readPayload();
+        const threadId = input.threadId || "pending";
+        const messages = payload.messagesByThread[threadId] ?? [];
+        const message = {
+            id: randomId(),
+            timestamp: input.timestamp ?? new Date().toISOString(),
+            ...input,
+            threadId,
+        };
+        messages.push(message);
+        if (messages.length > this.maxMessages) {
+            messages.splice(0, messages.length - this.maxMessages);
+        }
+        payload.messagesByThread[threadId] = messages;
+        this.store.write(payload);
+        return message;
+    }
+    list(threadId, limit = 200) {
+        const messages = this.readPayload().messagesByThread[threadId || "pending"] ?? [];
+        return messages.slice(-Math.max(1, Math.min(this.maxMessages, limit)));
+    }
+    clear(threadId) {
+        const payload = this.readPayload();
+        const key = threadId || "pending";
+        const count = payload.messagesByThread[key]?.length ?? 0;
+        delete payload.messagesByThread[key];
+        this.store.write(payload);
+        return count;
+    }
+    readPayload() {
+        const payload = this.store.read();
+        if (!payload || payload.version !== 1 || !payload.messagesByThread || typeof payload.messagesByThread !== "object") {
+            return { version: 1, messagesByThread: {} };
+        }
+        const messagesByThread = {};
+        for (const [threadId, messages] of Object.entries(payload.messagesByThread)) {
+            if (Array.isArray(messages)) {
+                messagesByThread[threadId] = messages.filter(isWebChatMessage).slice(-this.maxMessages);
+            }
+        }
+        return { version: 1, messagesByThread };
+    }
+}
+export class WebActivityStore {
+    store;
+    maxEvents;
+    constructor(workspace, backend = "json", maxEvents = DEFAULT_ACTIVITY_LIMIT) {
+        this.store = createDocumentStore({
+            workspace,
+            fileName: "web-activity.json",
+            sqliteKey: "web-activity",
+            backend,
+        });
+        this.maxEvents = maxEvents;
+    }
+    append(input) {
+        const payload = this.readPayload();
+        const event = {
+            id: randomId(),
+            timestamp: input.timestamp ?? new Date().toISOString(),
+            ...input,
+        };
+        payload.events.push(event);
+        if (payload.events.length > this.maxEvents) {
+            payload.events.splice(0, payload.events.length - this.maxEvents);
+        }
+        this.store.write(payload);
+        return event;
+    }
+    list(options = {}) {
+        const limit = Math.max(1, Math.min(500, options.limit ?? 100));
+        return this.readPayload().events
+            .filter((event) => !options.source || options.source === "all" || event.source === options.source)
+            .filter((event) => !options.status || options.status === "all" || event.status === options.status)
+            .slice(-limit)
+            .reverse();
+    }
+    readPayload() {
+        const payload = this.store.read();
+        if (!payload || payload.version !== 1 || !Array.isArray(payload.events)) {
+            return { version: 1, events: [] };
+        }
+        return {
+            version: 1,
+            events: payload.events.filter(isWebActivityEvent).slice(-this.maxEvents),
+        };
+    }
+}
+function isWebChatMessage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.id === "string" &&
+        typeof candidate.threadId === "string" &&
+        typeof candidate.text === "string" &&
+        typeof candidate.timestamp === "string" &&
+        ["user", "agent", "system", "tool"].includes(candidate.role) &&
+        ["web", "cli"].includes(candidate.source);
+}
+function isWebActivityEvent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.id === "string" &&
+        typeof candidate.timestamp === "string" &&
+        typeof candidate.type === "string" &&
+        ["web", "cli"].includes(candidate.source) &&
+        ["queued", "running", "completed", "failed", "aborted", "info"].includes(candidate.status);
+}
+function randomId() {
+    return randomUUID().replace(/-/g, "").slice(0, 12);
+}

package/docker-compose.yml

@@ -3,7 +3,7 @@ services:
     build: .
     env_file: .env
     volumes:
-      - ${HOME}/.codex:/home/nordrelay/.codex:rw
+      - ${HOME}/.nordrelay:/home/nordrelay/.nordrelay:rw
       - ./workspace:/workspace:rw
     cap_drop:
       - ALL

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nordbyte/nordrelay",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "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,19 +1,22 @@
 #!/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), "..");
 const DEFAULT_MARKETPLACE_ROOT = path.resolve(PLUGIN_ROOT, "../..");
 const RUNTIME_ROOT = findRuntimeRoot();
-const DEFAULT_HOME = path.join(os.homedir(), ".codex", "nordrelay");
+const DEFAULT_HOME = path.join(os.homedir(), ".nordrelay");
 
 function nowIso() {
   return new Date().toISOString();
@@ -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");
@@ -63,16 +77,11 @@ async function mkdirp(dir) {
 }
 
 function loadEnvFiles(home) {
-  const files = [
-    path.join(process.cwd(), ".env"),
-    path.join(RUNTIME_ROOT, ".env"),
-    path.join(PLUGIN_ROOT, ".env"),
-    path.join(home, "nordrelay.env"),
-  ];
+  const envPath = process.env.NORDRELAY_ENV_FILE
+    ? path.resolve(process.env.NORDRELAY_ENV_FILE)
+    : path.join(home, "nordrelay.env");
 
-  for (const envPath of files) {
-    loadEnvFile(envPath);
-  }
+  loadEnvFile(envPath);
 
   normalizeEnvAliases();
 }
@@ -193,7 +202,7 @@ async function commandStart(options) {
       await fsp.rm(options.pidFile, { force: true });
     }
     console.log(`Startup failed. Log: ${options.logFile}`);
-    console.log(state.error || "Unknown error");
+    console.log(state.error || await readStartupError(options.logFile) || "Unknown error");
     process.exitCode = 1;
     return;
   }
@@ -254,6 +263,125 @@ 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"));
+  const stateBackendCheck = validateStateBackend();
+  checks.push(check("State backend", stateBackendCheck.ok, stateBackendCheck.detail));
+  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);
@@ -307,12 +435,14 @@ async function commandForeground(options) {
     child.once("exit", (code, signal) => resolve({ code, signal }));
   });
 
+  const previousState = await readJson(options.stateFile, {});
   await writeJsonAtomic(options.stateFile, {
     status: exit.code === 0 ? "stopped" : "error",
     pid: process.pid,
     updatedAt: nowIso(),
     exitCode: exit.code,
     signal: exit.signal,
+    error: exit.code === 0 ? undefined : previousState.error,
     logFile: options.logFile,
   });
 
@@ -338,6 +468,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 +511,80 @@ 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 { ok: true, detail: "NORDRELAY_STATE_BACKEND=json" };
+  if (backend !== "sqlite") return { ok: false, detail: `Invalid NORDRELAY_STATE_BACKEND=${backend}` };
+  try {
+    const Database = require("better-sqlite3");
+    const filePath = path.join(process.cwd(), ".nordrelay", "state.sqlite");
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const db = new Database(filePath);
+    db.exec([
+      "CREATE TABLE IF NOT EXISTS documents (",
+      "key TEXT PRIMARY KEY,",
+      "json TEXT NOT NULL,",
+      "updated_at TEXT NOT NULL",
+      ")",
+    ].join(" "));
+    db.close?.();
+    return { ok: true, detail: `NORDRELAY_STATE_BACKEND=sqlite (${filePath})` };
+  } catch (error) {
+    return {
+      ok: false,
+      detail: `NORDRELAY_STATE_BACKEND=sqlite failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+async function readStartupError(logFile) {
+  try {
+    const lines = (await fsp.readFile(logFile, "utf8")).split(/\r?\n/).filter(Boolean).slice(-80).reverse();
+    const startupLine = lines.find((line) => line.includes("Failed to start NordRelay:"));
+    if (startupLine) return startupLine.replace(/^.*Failed to start NordRelay:\s*/, "");
+    const errorLine = lines.find((line) => /\bERROR\b/i.test(line));
+    if (errorLine) return errorLine;
+    return lines[0] || null;
+  } catch {
+    return null;
+  }
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -375,6 +594,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 +608,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;
 }