@nordbyte/nordrelay 0.5.1 → 0.6.0

package/plugins/nordrelay/scripts/nordrelay.mjs

@@ -51,6 +51,8 @@ function parseArgs(argv) {
     force: false,
     host: undefined,
     port: undefined,
+    restartAfterUpdate: true,
+    updateMethod: undefined,
   };
 
   for (let i = 0; i < copy.length; i += 1) {
@@ -60,7 +62,14 @@ function parseArgs(argv) {
     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 === "--method") options.updateMethod = requireValue(copy, ++i, arg);
+    else if (arg === "--no-restart") options.restartAfterUpdate = false;
+    else if (arg === "--restart") options.restartAfterUpdate = true;
     else if (arg === "--token") options.telegramBotToken = requireValue(copy, ++i, arg);
+    else if (arg === "--disable-telegram") options.disableTelegram = true;
+    else if (arg === "--enable-discord") options.enableDiscord = true;
+    else if (arg === "--discord-token") options.discordBotToken = requireValue(copy, ++i, arg);
+    else if (arg === "--discord-client-id") options.discordClientId = requireValue(copy, ++i, arg);
     else if (arg === "--admin-email") options.adminEmail = requireValue(copy, ++i, arg);
     else if (arg === "--admin-name") options.adminName = requireValue(copy, ++i, arg);
     else if (arg === "--admin-password") options.adminPassword = requireValue(copy, ++i, arg);
@@ -76,6 +85,9 @@ function parseArgs(argv) {
   options.pidFile = path.join(options.home, "nordrelay.pid");
   options.stateFile = path.join(options.home, "state.json");
   options.logFile = path.join(options.home, "nordrelay.log");
+  options.webPidFile = path.join(options.home, "nordrelay-web.pid");
+  options.webStateFile = path.join(options.home, "web-state.json");
+  options.webLogFile = path.join(options.home, "nordrelay-web.log");
   return options;
 }
 
@@ -170,6 +182,26 @@ async function readPid(pidFile) {
   }
 }
 
+async function readWebState(options) {
+  return await readJson(options.webStateFile, {});
+}
+
+async function readWebPid(options) {
+  return await readPid(options.webPidFile);
+}
+
+async function isWebDashboardRunning(options) {
+  return isProcessRunning(await readWebPid(options));
+}
+
+async function writeWebState(options, patch) {
+  await writeJsonAtomic(options.webStateFile, {
+    updatedAt: nowIso(),
+    logFile: options.webLogFile,
+    ...patch,
+  });
+}
+
 function resolveDashboardEndpoint(options, settings = {}) {
   const host = options.host || process.env.NORDRELAY_DASHBOARD_HOST || "127.0.0.1";
   const rawPort = options.port ?? Number.parseInt(process.env.NORDRELAY_DASHBOARD_PORT || "31878", 10);
@@ -228,7 +260,9 @@ async function commandStart(options, settings = {}) {
     console.log(`Workspace: ${state.workspace || "-"}`);
     console.log(`Mode: ${state.sessionMode || "per Telegram context"}`);
     if (!settings.skipWebHint) {
-      console.log(`WebUI: ${formatDashboardUrl(dashboard)} (run \`nordrelay web\` to start it)`);
+      const webPid = await readWebPid(options);
+      const webHint = isProcessRunning(webPid) ? `(running with PID ${webPid})` : "(run `nordrelay web` to start it)";
+      console.log(`WebUI: ${formatDashboardUrl(dashboard)} ${webHint}`);
     }
     console.log(`Log: ${options.logFile}`);
     return;
@@ -246,7 +280,9 @@ async function commandStart(options, settings = {}) {
 
   console.log(`Started ${APP_NAME} ${VERSION} with PID ${child.pid}`);
   if (!settings.skipWebHint) {
-    console.log(`WebUI: ${formatDashboardUrl(dashboard)} (run \`nordrelay web\` to start it)`);
+    const webPid = await readWebPid(options);
+    const webHint = isProcessRunning(webPid) ? `(running with PID ${webPid})` : "(run `nordrelay web` to start it)";
+    console.log(`WebUI: ${formatDashboardUrl(dashboard)} ${webHint}`);
   }
   console.log(`Startup is still in progress. Log: ${options.logFile}`);
 }
@@ -281,7 +317,51 @@ async function waitForState(stateFile, pid, timeoutMs) {
   return await readJson(stateFile);
 }
 
-async function commandStop(options) {
+async function stopWebDashboard(options, settings = {}) {
+  const pid = await readWebPid(options);
+  if (!isProcessRunning(pid)) {
+    await fsp.rm(options.webPidFile, { force: true });
+    const state = await readWebState(options);
+    if (state.status === "running" || state.status === "starting") {
+      await writeWebState(options, { status: "stopped", pid: null });
+    }
+    if (!settings.quiet) {
+      console.log("WebUI is not running.");
+    }
+    return false;
+  }
+
+  process.kill(pid, "SIGTERM");
+  for (let i = 0; i < 40; i += 1) {
+    if (!isProcessRunning(pid)) break;
+    await sleep(250);
+  }
+
+  if (isProcessRunning(pid)) {
+    process.kill(pid, "SIGKILL");
+    for (let i = 0; i < 20; i += 1) {
+      if (!isProcessRunning(pid)) break;
+      await sleep(250);
+    }
+  }
+
+  if (isProcessRunning(pid)) {
+    console.log(`WebUI PID ${pid} did not exit after SIGTERM/SIGKILL.`);
+    process.exitCode = 1;
+    return false;
+  }
+  await fsp.rm(options.webPidFile, { force: true });
+  await writeWebState(options, { status: "stopped", pid: null });
+  if (!settings.quiet) {
+    console.log(`Stopped WebUI PID ${pid}.`);
+  }
+  return true;
+}
+
+async function commandStop(options, settings = {}) {
+  if (!settings.keepWeb) {
+    await stopWebDashboard(options);
+  }
   const pid = await readPid(options.pidFile);
   if (!isProcessRunning(pid)) {
     console.log("Connector is not running.");
@@ -308,10 +388,19 @@ async function commandStatus(options) {
   loadEnvFiles(options.home);
   const dashboard = resolveDashboardEndpoint(options);
   const pid = await readPid(options.pidFile);
+  const webPid = await readWebPid(options);
   const state = await readJson(options.stateFile, {});
+  const webState = await readWebState(options);
   const running = isProcessRunning(pid);
+  const webRunning = isProcessRunning(webPid);
+  const webStatus = webRunning ? "running" : webState.status === "running" || webState.status === "starting" ? "stale" : webState.status || "stopped";
+  if (!webRunning && (webState.status === "running" || webState.status === "starting")) {
+    await fsp.rm(options.webPidFile, { force: true });
+    await writeWebState(options, { status: "stopped", pid: null });
+  }
   console.log(`Status: ${state.status || (running ? "running" : "stopped")}`);
   console.log(`PID: ${pid || "-"} (${running ? "running" : "not running"})`);
+  console.log(`WebUI PID: ${webPid || "-"} (${webRunning ? "running" : "not running"})`);
   console.log(`Workspace: ${state.workspace || "-"}`);
   console.log(`Mode: ${state.sessionMode || "per Telegram context"}`);
   console.log(`Auth: ${state.authenticated === undefined ? "-" : state.authenticated ? "yes" : "no"}`);
@@ -321,11 +410,250 @@ async function commandStatus(options) {
   console.log(`OpenClaw CLI: ${state.openClawCli || "-"}`);
   console.log(`Claude Code CLI: ${state.claudeCodeCli || "-"}`);
   console.log(`OpenClaw Gateway: ${state.openClawGateway || process.env.OPENCLAW_GATEWAY_URL || "-"}`);
-  console.log(`WebUI: ${formatDashboardUrl(dashboard)}`);
+  console.log(`WebUI: ${formatDashboardUrl(dashboard)} (${webStatus})`);
   console.log(`Log: ${options.logFile}`);
+  console.log(`WebUI log: ${options.webLogFile}`);
   if (state.error) console.log(`Error: ${state.error}`);
 }
 
+async function commandUpdate(options) {
+  await mkdirp(options.home);
+  loadEnvFiles(options.home);
+  const method = resolveUpdateMethod(options);
+  const updateLog = path.join(options.home, "update.log");
+  await mkdirp(path.dirname(updateLog));
+  const log = fs.createWriteStream(updateLog, { flags: "a" });
+  const sourceRoot = RUNTIME_ROOT;
+  const wasRunning = isProcessRunning(await readPid(options.pidFile));
+  const summary = method === "npm"
+    ? "Install latest @nordbyte/nordrelay with npm, verify the CLI, and restart if the connector is running."
+    : "Pull origin/main, install dependencies, run check, tests, build, and restart if the connector is running.";
+
+  console.log(`Starting NordRelay update (${method}).`);
+  console.log(`Source: ${sourceRoot}`);
+  console.log(`Log: ${updateLog}`);
+  logUpdateLine(log, `Starting ${method} connector self-update`);
+  logUpdateLine(log, summary);
+
+  try {
+    if (method === "npm") {
+      await runNpmSelfUpdate(sourceRoot, log);
+    } else {
+      await runGitSelfUpdate(sourceRoot, log);
+    }
+
+    if (options.restartAfterUpdate && wasRunning) {
+      await runLoggedStep(log, "Restart NordRelay connector", process.execPath, [
+        SCRIPT_PATH,
+        "restart",
+        "--keep-pending-updates",
+        "--home",
+        options.home,
+      ], { cwd: sourceRoot });
+    } else if (options.restartAfterUpdate) {
+      logUpdateLine(log, "Connector was not running; restart skipped.");
+      console.log("Connector was not running; restart skipped.");
+    } else {
+      logUpdateLine(log, "Restart skipped by --no-restart.");
+      console.log("Restart skipped by --no-restart.");
+    }
+
+    logUpdateLine(log, "NordRelay update completed.");
+    console.log("NordRelay update completed.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logUpdateLine(log, `ERROR ${message}`);
+    console.error(`Update failed: ${message}`);
+    process.exitCode = 1;
+  } finally {
+    await closeLogStream(log);
+  }
+}
+
+function resolveUpdateMethod(options) {
+  const requested = (options.updateMethod || process.env.NORDRELAY_UPDATE_METHOD || "auto").trim().toLowerCase();
+  if (!requested || requested === "auto") {
+    return fs.existsSync(path.join(RUNTIME_ROOT, ".git")) ? "git" : "npm";
+  }
+  if (requested === "npm" || requested === "git") {
+    return requested;
+  }
+  throw new Error(`Unsupported update method "${requested}". Use auto, npm, or git.`);
+}
+
+async function runNpmSelfUpdate(sourceRoot, log) {
+  const npm = resolveNpmSpawnCommand();
+  if (!npm) {
+    throw new Error("npm was not found. Install Node.js/npm or add npm to PATH.");
+  }
+  await runLoggedStep(log, "Install latest NordRelay package", npm.command, [
+    ...npm.argsPrefix,
+    "install",
+    "-g",
+    "@nordbyte/nordrelay@latest",
+  ], { cwd: os.homedir(), shell: npm.shell });
+  await runVerifyNordRelayCli(sourceRoot, log);
+}
+
+async function runGitSelfUpdate(sourceRoot, log) {
+  const git = resolveRequiredCommand("git");
+  const npm = resolveNpmSpawnCommand();
+  if (!npm) {
+    throw new Error("npm was not found. Install Node.js/npm or add npm to PATH.");
+  }
+  await runLoggedStep(log, "Pull latest source", git.command, ["pull", "--ff-only", "origin", "main"], { cwd: sourceRoot, shell: git.shell });
+  await runLoggedStep(log, "Install dependencies", npm.command, [...npm.argsPrefix, "install"], { cwd: sourceRoot, shell: npm.shell });
+  await runLoggedStep(log, "Run checks", npm.command, [...npm.argsPrefix, "run", "check"], { cwd: sourceRoot, shell: npm.shell });
+  await runLoggedStep(log, "Run tests", npm.command, [...npm.argsPrefix, "test"], { cwd: sourceRoot, shell: npm.shell });
+  await runLoggedStep(log, "Build runtime", npm.command, [...npm.argsPrefix, "run", "build"], { cwd: sourceRoot, shell: npm.shell });
+  await runVerifyNordRelayCli(sourceRoot, log);
+}
+
+async function runVerifyNordRelayCli(sourceRoot, log) {
+  if (fs.existsSync(SCRIPT_PATH)) {
+    await runLoggedStep(log, "Verify NordRelay CLI", process.execPath, [SCRIPT_PATH, "version"], { cwd: sourceRoot });
+    return;
+  }
+  const nordrelay = resolveRequiredCommand("nordrelay");
+  await runLoggedStep(log, "Verify NordRelay CLI", nordrelay.command, ["version"], { cwd: os.homedir(), shell: nordrelay.shell });
+}
+
+async function runLoggedStep(log, label, command, args, settings = {}) {
+  logUpdateLine(log, `${label}: ${formatCommand(command, args)}`);
+  console.log(`\n${label}`);
+  const useShell = Boolean(settings.shell);
+  const child = spawn(useShell ? formatShellCommand(command, args) : command, useShell ? [] : args, {
+    cwd: settings.cwd || RUNTIME_ROOT,
+    env: process.env,
+    shell: useShell,
+    stdio: ["inherit", "pipe", "pipe"],
+    windowsHide: false,
+  });
+
+  child.stdout?.on("data", (chunk) => {
+    safeWrite(process.stdout, chunk);
+    safeWrite(log, chunk);
+  });
+  child.stderr?.on("data", (chunk) => {
+    safeWrite(process.stderr, chunk);
+    safeWrite(log, chunk);
+  });
+
+  const exit = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve({ code, signal }));
+  });
+
+  if (exit.signal) {
+    throw new Error(`${label} stopped with signal ${exit.signal}`);
+  }
+  if (exit.code !== 0) {
+    throw new Error(`${label} failed with exit code ${exit.code ?? "unknown"}`);
+  }
+  logUpdateLine(log, `${label} completed`);
+}
+
+function resolveRequiredCommand(command) {
+  const resolved = findExecutable(command);
+  if (!resolved) {
+    throw new Error(`${command} was not found on PATH.`);
+  }
+  return {
+    command: resolved,
+    shell: isWindowsShellScript(resolved),
+  };
+}
+
+function resolveNpmSpawnCommand(env = process.env) {
+  const npmExecPath = env.npm_execpath?.trim();
+  if (npmExecPath && fs.existsSync(npmExecPath)) {
+    return {
+      command: process.execPath,
+      argsPrefix: [npmExecPath],
+      shell: false,
+    };
+  }
+
+  const pathMatch = findExecutable("npm", env.PATH);
+  if (pathMatch) {
+    return {
+      command: pathMatch,
+      argsPrefix: [],
+      shell: isWindowsShellScript(pathMatch),
+    };
+  }
+
+  for (const candidate of commonNpmCandidates(env)) {
+    if (!fs.existsSync(candidate)) continue;
+    return {
+      command: candidate,
+      argsPrefix: [],
+      shell: isWindowsShellScript(candidate),
+    };
+  }
+  return null;
+}
+
+function commonNpmCandidates(env) {
+  const names = process.platform === "win32" ? ["npm.cmd", "npm.bat", "npm"] : ["npm"];
+  const directories = [
+    path.dirname(process.execPath),
+    env.APPDATA ? path.join(env.APPDATA, "npm") : undefined,
+    env.ProgramFiles ? path.join(env.ProgramFiles, "nodejs") : undefined,
+    env["ProgramFiles(x86)"] ? path.join(env["ProgramFiles(x86)"], "nodejs") : undefined,
+  ].filter(Boolean);
+  return directories.flatMap((directory) => names.map((name) => path.join(directory, name)));
+}
+
+function logUpdateLine(log, message) {
+  safeWrite(log, `[${nowIso()}] ${message}\n`);
+}
+
+function safeWrite(stream, chunk) {
+  try {
+    stream.write(chunk);
+  } catch {
+    // Logging must not break the updater if stdout/stderr disappears.
+  }
+}
+
+function closeLogStream(log) {
+  return new Promise((resolve) => {
+    log.end(resolve);
+  });
+}
+
+function formatCommand(command, args) {
+  return [command, ...args].map((part) => {
+    const text = String(part);
+    return /[\s"'$`\\]/.test(text) ? JSON.stringify(text) : text;
+  }).join(" ");
+}
+
+function formatShellCommand(command, args) {
+  return [command, ...args].map(quoteShellArg).join(" ");
+}
+
+function quoteShellArg(value) {
+  if (process.platform === "win32") {
+    return quoteWindowsCmdArg(String(value));
+  }
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function quoteWindowsCmdArg(value) {
+  if (value.length === 0) {
+    return "\"\"";
+  }
+  if (!/[\s"&|<>()^%]/.test(value)) {
+    return value;
+  }
+  return `"${value
+    .replace(/%/g, "%%")
+    .replace(/(\\*)"/g, '$1$1\\"')
+    .replace(/(\\+)$/g, "$1$1")}"`;
+}
+
 async function commandInit(options) {
   await mkdirp(options.home);
   const envPath = path.join(options.home, "nordrelay.env");
@@ -336,9 +664,17 @@ async function commandInit(options) {
     return;
   }
 
-  const telegramBotToken = options.telegramBotToken ||
-    process.env.TELEGRAM_BOT_TOKEN ||
-    await ask(null, "Telegram bot token", "");
+  const enableTelegram = options.disableTelegram ? "false" : await askChoice(null, "Enable Telegram", "true");
+  const telegramBotToken = enableTelegram === "true"
+    ? options.telegramBotToken || process.env.TELEGRAM_BOT_TOKEN || await ask(null, "Telegram bot token", "")
+    : "";
+  const enableDiscord = options.enableDiscord ? "true" : await askChoice(null, "Enable Discord", "false");
+  const discordBotToken = enableDiscord === "true"
+    ? options.discordBotToken || process.env.DISCORD_BOT_TOKEN || await ask(null, "Discord bot token", "")
+    : "";
+  const discordClientId = enableDiscord === "true"
+    ? options.discordClientId || process.env.DISCORD_CLIENT_ID || await ask(null, "Discord client ID", "")
+    : "";
   const adminEmail = options.adminEmail || await ask(null, "Admin email", "");
   const adminName = options.adminName || await ask(null, "Admin name", "Admin");
   const adminPassword = options.adminPassword || await askSecret(null, "Admin password", "");
@@ -350,7 +686,9 @@ async function commandInit(options) {
   const enableClaudeCode = options.enableClaudeCode ? "true" : await askChoice(null, "Enable Claude Code", "false");
   const stateBackend = options.stateBackend || await askChoice(null, "State backend (json/sqlite)", "json");
 
-  if (!telegramBotToken) throw new Error("Telegram bot token is required.");
+  if (enableTelegram === "true" && !telegramBotToken) throw new Error("Telegram bot token is required when Telegram is enabled.");
+  if (enableDiscord === "true" && !discordBotToken) throw new Error("Discord bot token is required when Discord is enabled.");
+  if (enableTelegram !== "true" && enableDiscord !== "true") throw new Error("At least one chat adapter must be enabled.");
   if (!adminEmail) throw new Error("Admin email is required.");
   if (!adminPassword) throw new Error("Admin password is required.");
   if (enableCodex !== "true" && enablePi !== "true" && enableHermes !== "true" && enableOpenClaw !== "true" && enableClaudeCode !== "true") throw new Error("At least one agent must be enabled.");
@@ -367,7 +705,14 @@ async function commandInit(options) {
   const lines = [
     "# NordRelay local runtime config.",
     "# Keep this file private; it contains bot credentials.",
+    `TELEGRAM_ENABLED=${enableTelegram}`,
     `TELEGRAM_BOT_TOKEN=${telegramBotToken}`,
+    `DISCORD_ENABLED=${enableDiscord}`,
+    `DISCORD_BOT_TOKEN=${discordBotToken}`,
+    `DISCORD_CLIENT_ID=${discordClientId}`,
+    "DISCORD_COMMAND_MODE=both",
+    "DISCORD_MESSAGE_CONTENT_ENABLED=true",
+    "DISCORD_AUTO_REGISTER_COMMANDS=true",
     `NORDRELAY_CODEX_ENABLED=${enableCodex}`,
     `NORDRELAY_PI_ENABLED=${enablePi}`,
     `NORDRELAY_HERMES_ENABLED=${enableHermes}`,
@@ -421,6 +766,7 @@ function parseUserFlags(argv) {
     else if (arg === "--password") flags.password = requireValue(copy, ++i, arg);
     else if (arg === "--group" || arg === "--groups") flags.groups = requireValue(copy, ++i, arg);
     else if (arg === "--telegram-user-id") flags.telegramUserId = Number.parseInt(requireValue(copy, ++i, arg), 10);
+    else if (arg === "--discord-user-id") flags.discordUserId = requireValue(copy, ++i, arg);
     else if (arg === "--user-id") flags.userId = requireValue(copy, ++i, arg);
   }
   return flags;
@@ -452,8 +798,8 @@ async function commandUser(options) {
       ? ["admin"]
       : (flags.groups ? flags.groups.split(",").map((item) => item.trim()).filter(Boolean) : ["user"]);
     const created = flags.subcommand === "create-admin"
-      ? store.createAdmin({ email, displayName: name, password, telegramUserId: flags.telegramUserId })
-      : store.createUser({ email, displayName: name, password, groupIds, telegramUserId: flags.telegramUserId });
+      ? store.createAdmin({ email, displayName: name, password, telegramUserId: flags.telegramUserId, discordUserId: flags.discordUserId })
+      : store.createUser({ email, displayName: name, password, groupIds, telegramUserId: flags.telegramUserId, discordUserId: flags.discordUserId });
     console.log(`Created user ${created.user.email} (${created.groups.map((group) => group.name).join(", ")}).`);
     return;
   }
@@ -478,7 +824,17 @@ async function commandUser(options) {
     return;
   }
 
-  if (flags.subcommand === "link-code") {
+  if (flags.subcommand === "link-discord") {
+    const email = flags.email || await ask(null, "Email", "");
+    const discordUserId = flags.discordUserId || await ask(null, "Discord user id", "");
+    const user = store.getUserByEmail(email);
+    if (!user) throw new Error(`User not found: ${email}`);
+    store.linkDiscordUser(user.user.id, { discordUserId });
+    console.log(`Linked Discord user ${discordUserId} to ${user.user.email}.`);
+    return;
+  }
+
+  if (flags.subcommand === "link-code" || flags.subcommand === "telegram-link-code") {
     const email = flags.email || await ask(null, "Email", "");
     const user = store.getUserByEmail(email);
     if (!user) throw new Error(`User not found: ${email}`);
@@ -488,7 +844,17 @@ async function commandUser(options) {
     return;
   }
 
-  throw new Error("Usage: nordrelay user [list|create-admin|create|reset-password|link-telegram|link-code]");
+  if (flags.subcommand === "discord-link-code") {
+    const email = flags.email || await ask(null, "Email", "");
+    const user = store.getUserByEmail(email);
+    if (!user) throw new Error(`User not found: ${email}`);
+    const code = store.createDiscordLinkCode(user.user.id);
+    console.log(`Discord link code for ${user.user.email}: ${code.code}`);
+    console.log(`Expires: ${code.expiresAt}`);
+    return;
+  }
+
+  throw new Error("Usage: nordrelay user [list|create-admin|create|reset-password|link-telegram|link-discord|link-code|telegram-link-code|discord-link-code]");
 }
 
 async function commandDoctor(options) {
@@ -498,11 +864,16 @@ async function commandDoctor(options) {
   const userSnapshot = userStore?.snapshot();
   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"));
+  const telegramEnabled = process.env.TELEGRAM_ENABLED !== "false";
+  const discordEnabled = process.env.DISCORD_ENABLED === "true";
+  checks.push(check("Telegram bot token", !telegramEnabled || Boolean(process.env.TELEGRAM_BOT_TOKEN), telegramEnabled ? (process.env.TELEGRAM_BOT_TOKEN ? "configured" : "missing") : "disabled", telegramEnabled ? "fail" : "warn"));
+  checks.push(check("Discord bot token", !discordEnabled || Boolean(process.env.DISCORD_BOT_TOKEN), discordEnabled ? (process.env.DISCORD_BOT_TOKEN ? "configured" : "missing") : "disabled", discordEnabled ? "fail" : "warn"));
+  checks.push(check("Discord client ID", !discordEnabled || Boolean(process.env.DISCORD_CLIENT_ID), discordEnabled ? (process.env.DISCORD_CLIENT_ID ? "configured" : "missing; slash command auto-registration disabled") : "disabled", "warn"));
   checks.push(check("User store", Boolean(userStore), userStore ? userStore.filePath : "missing runtime", userStore ? "pass" : "fail"));
   checks.push(check("Admin user", Boolean(userSnapshot?.adminConfigured), userSnapshot?.adminConfigured ? "configured" : "missing"));
   checks.push(check("WebUI login", true, "required for every dashboard request"));
   checks.push(check("Telegram access", true, "requires linked active users and enabled group chats"));
+  checks.push(check("Discord access", true, "requires linked active users and enabled channels"));
   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("Hermes enabled flag", process.env.NORDRELAY_HERMES_ENABLED === "true", `NORDRELAY_HERMES_ENABLED=${process.env.NORDRELAY_HERMES_ENABLED ?? "false"}`, process.env.NORDRELAY_HERMES_ENABLED === "true" ? "pass" : "warn"));
@@ -607,8 +978,21 @@ async function checkOpenClawGateway() {
 async function commandWeb(options) {
   await mkdirp(options.home);
   loadEnvFiles(options.home);
-  const { host, port } = resolveDashboardEndpoint(options, { strict: true });
   await ensureConnectorStartedForWeb(options);
+  await startWebDashboard(options, { detached: false });
+}
+
+async function startWebDashboard(options, settings = {}) {
+  await mkdirp(options.home);
+  loadEnvFiles(options.home);
+  const { host, port } = resolveDashboardEndpoint(options, { strict: true });
+  const currentPid = await readWebPid(options);
+  if (isProcessRunning(currentPid)) {
+    console.log(`NordRelay dashboard already running with PID ${currentPid}.`);
+    console.log(`NordRelay dashboard: ${formatDashboardUrl({ host, port })}`);
+    return;
+  }
+  await fsp.rm(options.webPidFile, { force: true });
   const entry = await resolveWebRuntimeEntry();
   if (!entry) {
     throw new Error(`Missing dashboard runtime. Run \`npm install\` and \`npm run build\` in ${RUNTIME_ROOT}.`);
@@ -621,12 +1005,43 @@ async function commandWeb(options) {
     NORDRELAY_DASHBOARD_HOST: host,
     NORDRELAY_DASHBOARD_PORT: String(port),
   };
+  await writeWebState(options, {
+    status: "starting",
+    pid: null,
+    host,
+    port,
+    url: formatDashboardUrl({ host, port }),
+  });
+  const stdio = settings.detached
+    ? ["ignore", fs.openSync(options.webLogFile, "a"), fs.openSync(options.webLogFile, "a")]
+    : "inherit";
   const child = spawn(entry.command, [...entry.args, "--host", host, "--port", String(port), "--home", options.home], {
     cwd: RUNTIME_ROOT,
     env,
-    stdio: "inherit",
+    detached: Boolean(settings.detached),
+    stdio,
+  });
+  await fsp.writeFile(options.webPidFile, `${child.pid}\n`);
+  await writeWebState(options, {
+    status: "running",
+    pid: child.pid,
+    host,
+    port,
+    url: formatDashboardUrl({ host, port }),
   });
 
+  if (settings.detached) {
+    child.unref();
+    if (Array.isArray(stdio)) {
+      fs.closeSync(stdio[1]);
+      fs.closeSync(stdio[2]);
+    }
+    console.log(`NordRelay dashboard started with PID ${child.pid}.`);
+    console.log(`NordRelay dashboard: ${formatDashboardUrl({ host, port })}`);
+    console.log(`WebUI log: ${options.webLogFile}`);
+    return;
+  }
+
   const forwardSignal = (signal) => {
     if (isProcessRunning(child.pid)) {
       child.kill(signal);
@@ -635,9 +1050,23 @@ async function commandWeb(options) {
   process.once("SIGINT", () => forwardSignal("SIGINT"));
   process.once("SIGTERM", () => forwardSignal("SIGTERM"));
 
-  const exit = await new Promise((resolve) => {
+  const exit = await new Promise((resolve, reject) => {
+    child.once("error", reject);
     child.once("exit", (code, signal) => resolve({ code, signal }));
   });
+  const pid = await readWebPid(options);
+  if (pid === child.pid) {
+    await fsp.rm(options.webPidFile, { force: true });
+  }
+  await writeWebState(options, {
+    status: exit.code === 0 ? "stopped" : "error",
+    pid: null,
+    host,
+    port,
+    url: formatDashboardUrl({ host, port }),
+    exitCode: exit.code,
+    signal: exit.signal,
+  });
   if (exit.signal) {
     process.kill(process.pid, exit.signal);
     return;
@@ -858,17 +1287,26 @@ function check(name, ok, detail, status = "fail") {
   };
 }
 
-function findExecutable(command) {
+function findExecutable(command, pathValue = process.env.PATH, pathextValue = process.env.PATHEXT) {
   if (!command) return null;
   if (command.includes(path.sep) && fs.existsSync(command)) return command;
-  const paths = (process.env.PATH || "").split(path.delimiter);
+  const paths = (pathValue || "").split(path.delimiter);
+  const extensions = process.platform === "win32"
+    ? ["", ...(pathextValue || ".COM;.EXE;.BAT;.CMD").split(";")]
+    : [""];
   for (const dir of paths) {
-    const candidate = path.join(dir, command);
-    if (fs.existsSync(candidate)) return candidate;
+    for (const extension of extensions) {
+      const candidate = path.join(dir, `${command}${extension}`);
+      if (fs.existsSync(candidate)) return candidate;
+    }
   }
   return null;
 }
 
+function isWindowsShellScript(filePath) {
+  return process.platform === "win32" && /\.(?:cmd|bat)$/i.test(filePath);
+}
+
 function validateStateBackend() {
   const backend = process.env.NORDRELAY_STATE_BACKEND || "json";
   if (backend === "json") return { ok: true, detail: "NORDRELAY_STATE_BACKEND=json" };
@@ -920,10 +1358,18 @@ async function main() {
   if (options.command === "init") return commandInit(options);
   if (options.command === "user") return commandUser(options);
   if (options.command === "doctor") return commandDoctor(options);
+  if (options.command === "update") return commandUpdate(options);
   if (options.command === "web" || options.command === "dashboard") return commandWeb(options);
   if (options.command === "restart") {
+    await mkdirp(options.home);
+    loadEnvFiles(options.home);
+    const webWasRunning = await isWebDashboardRunning(options);
     await commandStop(options);
-    return commandStart(options);
+    await commandStart(options);
+    if (webWasRunning && process.exitCode !== 1) {
+      await startWebDashboard(options, { detached: true });
+    }
+    return;
   }
   if (options.command === "foreground") return commandForeground(options);
   if (options.command === "--version" || options.command === "version") {
@@ -932,7 +1378,7 @@ async function main() {
   }
 
   console.error(`Unknown command: ${options.command}`);
-  console.error("Usage: nordrelay [init|user|doctor|web|start|stop|restart|status|foreground|version]");
+  console.error("Usage: nordrelay [init|user|doctor|web|start|stop|restart|status|update|foreground|version]");
   process.exitCode = 2;
 }