@nordbyte/nordrelay 0.6.0 → 0.7.0

package/dist/codex-state.js

@@ -1,6 +1,8 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { isCodexApprovalPolicy, isCodexSandboxMode, } from "./codex-launch.js";
+const ROLLOUT_CACHE_MAX_EVENTS = 200;
+const rolloutSnapshotCache = new Map();
 export const FALLBACK_MODELS = [
     { slug: "gpt-5.5", displayName: "GPT-5.5" },
     { slug: "gpt-5.4", displayName: "GPT-5.4" },
@@ -74,31 +76,7 @@ export function getThreadUsage(id) {
     }
 }
 export function getThreadActivity(id, options = {}) {
-    const rolloutPath = getThreadRolloutPath(id);
-    if (!rolloutPath || !existsSync(rolloutPath)) {
-        return null;
-    }
-    try {
-        const parsed = parseActivityFromRollout(id, rolloutPath, readFileSync(rolloutPath, "utf8"));
-        const fileModifiedAtMs = statSync(rolloutPath).mtimeMs;
-        const updatedAtMs = Math.max(parsed.updatedAt?.getTime() ?? 0, fileModifiedAtMs);
-        const updatedAt = updatedAtMs > 0 ? new Date(updatedAtMs) : parsed.updatedAt;
-        const staleAfterMs = options.staleAfterMs ?? 5 * 60 * 1000;
-        const nowMs = options.nowMs ?? Date.now();
-        const stale = Boolean(parsed.active &&
-            updatedAt &&
-            staleAfterMs > 0 &&
-            nowMs - updatedAt.getTime() > staleAfterMs);
-        return {
-            ...parsed,
-            updatedAt,
-            stale,
-            active: parsed.active && !stale,
-        };
-    }
-    catch {
-        return null;
-    }
+    return getThreadRolloutSnapshot(id, { ...options, maxEvents: 0 })?.activity ?? null;
 }
 export function getThreadRolloutSnapshot(id, options = {}) {
     const rolloutPath = getThreadRolloutPath(id);
@@ -106,8 +84,9 @@ export function getThreadRolloutSnapshot(id, options = {}) {
         return null;
     }
     try {
-        const parsed = parseRolloutSnapshot(id, rolloutPath, readFileSync(rolloutPath, "utf8"));
-        return finalizeRolloutSnapshot(parsed, statSync(rolloutPath).mtimeMs, options);
+        const fileModifiedAtMs = statSync(rolloutPath).mtimeMs;
+        const parsed = readCachedRolloutSnapshot(id, rolloutPath);
+        return finalizeRolloutSnapshot(parsed, fileModifiedAtMs, options);
     }
     catch {
         return null;
@@ -167,13 +146,7 @@ export function getThreadRolloutPath(id) {
     }) ?? null);
 }
 function parseUsageFromRollout(contents) {
-    let contextWindow = null;
-    let contextUsedPercent = null;
-    let lastTokenUsage = null;
-    let totalTokenUsage = null;
-    let rateLimits = null;
-    let updatedAt = null;
-    for (const line of contents.split(/\r?\n/)) {
+    for (const line of iterateLinesReverse(contents)) {
         if (!line.includes('"token_count"')) {
             continue;
         }
@@ -188,6 +161,7 @@ function parseUsageFromRollout(contents) {
         if (payload?.type !== "token_count") {
             continue;
         }
+        let updatedAt = null;
         const timestamp = readString(readObject(event)?.timestamp);
         if (timestamp) {
             const parsedTimestamp = new Date(timestamp);
@@ -196,54 +170,116 @@ function parseUsageFromRollout(contents) {
             }
         }
         const info = readObject(payload.info);
-        const parsedTotal = parseTokenUsage(readObject(info?.total_token_usage));
-        const parsedLast = parseTokenUsage(readObject(info?.last_token_usage));
+        const totalTokenUsage = parseTokenUsage(readObject(info?.total_token_usage));
+        const lastTokenUsage = parseTokenUsage(readObject(info?.last_token_usage));
         const parsedContextWindow = readNumber(info?.model_context_window);
-        if (parsedTotal) {
-            totalTokenUsage = parsedTotal;
+        const contextWindow = parsedContextWindow !== null && parsedContextWindow > 0
+            ? parsedContextWindow
+            : null;
+        const contextUsedPercent = lastTokenUsage && contextWindow
+            ? Math.min(100, (lastTokenUsage.totalTokens / contextWindow) * 100)
+            : null;
+        const rateLimits = parseRateLimits(readObject(payload.rate_limits));
+        if (!lastTokenUsage && !totalTokenUsage && !rateLimits) {
+            continue;
         }
-        if (parsedLast) {
-            lastTokenUsage = parsedLast;
+        return {
+            contextWindow,
+            contextUsedPercent,
+            lastTokenUsage,
+            totalTokenUsage,
+            rateLimits,
+            updatedAt,
+        };
+    }
+    return null;
+}
+function readCachedRolloutSnapshot(threadId, rolloutPath) {
+    const size = statSync(rolloutPath).size;
+    const cached = rolloutSnapshotCache.get(rolloutPath);
+    if (cached && size >= cached.byteOffset) {
+        const suffix = size > cached.byteOffset
+            ? readFileRangeUtf8(rolloutPath, cached.byteOffset, size - cached.byteOffset)
+            : "";
+        if (!suffix.trim()) {
+            return cached.parsed;
         }
-        if (parsedContextWindow !== null && parsedContextWindow > 0) {
-            contextWindow = parsedContextWindow;
+        const parsed = parseRolloutSnapshot(threadId, rolloutPath, suffix, {
+            base: cached.parsed,
+            maxEvents: ROLLOUT_CACHE_MAX_EVENTS,
+        });
+        rolloutSnapshotCache.set(rolloutPath, { byteOffset: size, parsed });
+        return parsed;
+    }
+    const contents = readFileSync(rolloutPath, "utf8");
+    const parsed = parseRolloutSnapshot(threadId, rolloutPath, contents, {
+        maxEvents: ROLLOUT_CACHE_MAX_EVENTS,
+    });
+    rolloutSnapshotCache.set(rolloutPath, {
+        byteOffset: Buffer.byteLength(contents),
+        parsed,
+    });
+    return parsed;
+}
+function readFileRangeUtf8(filePath, position, length) {
+    if (length <= 0) {
+        return "";
+    }
+    const fd = openSync(filePath, "r");
+    try {
+        const buffer = Buffer.allocUnsafe(length);
+        const bytesRead = readSync(fd, buffer, 0, length, position);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function* iterateLinesReverse(contents) {
+    let end = contents.length;
+    while (end > 0) {
+        let start = contents.lastIndexOf("\n", end - 1);
+        const lineStart = start === -1 ? 0 : start + 1;
+        let line = contents.slice(lineStart, end);
+        if (line.endsWith("\r")) {
+            line = line.slice(0, -1);
         }
-        if (lastTokenUsage && contextWindow) {
-            contextUsedPercent = Math.min(100, (lastTokenUsage.totalTokens / contextWindow) * 100);
+        if (line.trim()) {
+            yield line;
         }
-        const parsedRateLimits = parseRateLimits(readObject(payload.rate_limits));
-        if (parsedRateLimits) {
-            rateLimits = parsedRateLimits;
+        if (start === -1) {
+            break;
         }
+        end = start;
     }
-    if (!lastTokenUsage && !totalTokenUsage && !rateLimits) {
-        return null;
-    }
-    return {
-        contextWindow,
-        contextUsedPercent,
-        lastTokenUsage,
-        totalTokenUsage,
-        rateLimits,
-        updatedAt,
-    };
 }
-function parseActivityFromRollout(threadId, rolloutPath, contents) {
-    return parseRolloutSnapshot(threadId, rolloutPath, contents).activity;
-}
-function parseRolloutSnapshot(threadId, rolloutPath, contents) {
-    let activeTurnId = null;
-    let startedAt = null;
-    let updatedAt = null;
-    let latestAgentMessage = null;
-    let latestUserMessage = null;
-    let latestToolName = null;
-    const events = [];
+function parseRolloutSnapshot(threadId, rolloutPath, contents, options = {}) {
+    let activeTurnId = options.base?.activity.active ? options.base.activity.turnId : null;
+    let startedAt = options.base?.activity.active ? options.base.activity.startedAt : null;
+    let updatedAt = options.base?.activity.updatedAt ?? null;
+    let latestAgentMessage = options.base?.latestAgentMessage ?? null;
+    let latestUserMessage = options.base?.latestUserMessage ?? null;
+    let latestToolName = options.base?.latestToolName ?? null;
+    const events = [...(options.base?.events ?? [])];
     const lines = contents.split(/\r?\n/);
+    const lineNumberOffset = options.base?.lineCount ?? 0;
+    let lineCount = lineNumberOffset;
+    const afterLine = options.afterLine ?? 0;
+    const maxEvents = options.maxEvents ?? Number.POSITIVE_INFINITY;
+    const pushEvent = (event) => {
+        if (maxEvents <= 0 || event.lineNumber <= afterLine) {
+            return;
+        }
+        events.push(event);
+        if (Number.isFinite(maxEvents) && events.length > maxEvents) {
+            events.splice(0, events.length - maxEvents);
+        }
+    };
     for (const [index, line] of lines.entries()) {
         if (!line.trim()) {
             continue;
         }
+        lineCount += 1;
         if (!line.includes('"task_') &&
             !line.includes('"turn_') &&
             !line.includes('"user_message"') &&
@@ -262,7 +298,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         const eventObject = readObject(event);
         const payload = readObject(eventObject?.payload);
         const eventTimestamp = parseTimestamp(readString(eventObject?.timestamp));
-        const lineNumber = index + 1;
+        const lineNumber = lineNumberOffset + index + 1;
         if (activeTurnId && eventTimestamp) {
             updatedAt = eventTimestamp;
         }
@@ -274,7 +310,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
             activeTurnId = readString(payload?.turn_id);
             startedAt = parseUnixSeconds(readNumber(payload?.started_at)) ?? eventTimestamp;
             updatedAt = eventTimestamp ?? startedAt;
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "task",
                 timestamp: eventTimestamp,
@@ -289,7 +325,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         }
         if (isTaskTerminalEvent(type)) {
             const turnId = readString(payload?.turn_id);
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "task",
                 timestamp: eventTimestamp,
@@ -309,7 +345,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         }
         if (type === "user_message") {
             latestUserMessage = readString(payload?.message);
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "user",
                 timestamp: eventTimestamp,
@@ -324,7 +360,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         }
         if (type === "agent_message") {
             latestAgentMessage = readString(payload?.message);
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "agent",
                 timestamp: eventTimestamp,
@@ -339,7 +375,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         }
         if (type === "function_call") {
             latestToolName = readString(payload?.name);
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "tool",
                 timestamp: eventTimestamp,
@@ -353,7 +389,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
             continue;
         }
         if (type === "function_call_output") {
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "tool",
                 timestamp: eventTimestamp,
@@ -369,7 +405,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
     return {
         threadId,
         rolloutPath,
-        lineCount: lines.filter((line) => line.trim()).length,
+        lineCount,
         activity: {
             threadId,
             rolloutPath,

package/dist/config-metadata.js

@@ -128,6 +128,13 @@ export const SETTING_DEFINITIONS = [
     setting("NORDRELAY_UNIFIED_JOB_MAX_ITEMS", "Unified job history", "Workspace", "number", "Maximum persisted unified jobs retained for the WebUI jobs view.", true),
     setting("NORDRELAY_VERSION_CACHE_TTL_MS", "Version cache TTL", "Workspace", "number", "NPM version cache TTL.", true),
     setting("NORDRELAY_CLI_VERSION_CACHE_TTL_MS", "CLI version cache TTL", "Workspace", "number", "Installed agent CLI version cache TTL.", true),
+    setting("NORDRELAY_PEER_ENABLED", "Enable peer server", "Peers", "boolean", "Expose the dedicated authenticated NordRelay peer API.", true),
+    setting("NORDRELAY_PEER_NAME", "Peer display name", "Peers", "string", "Human-readable name shown to paired NordRelay instances.", true),
+    setting("NORDRELAY_PEER_HOST", "Peer bind host", "Peers", "string", "Bind host for the peer API. Use 127.0.0.1 for local-only or a LAN/interface IP when explicitly exposing peers.", true),
+    setting("NORDRELAY_PEER_PORT", "Peer port", "Peers", "number", "Port for the peer API.", true),
+    setting("NORDRELAY_PEER_PUBLIC_URL", "Peer public URL", "Peers", "string", "Optional public URL other instances should use for this node.", true),
+    setting("NORDRELAY_PEER_TLS_ENABLED", "Peer TLS enabled", "Peers", "boolean", "Serve the peer API over HTTPS with an automatically generated local certificate.", true),
+    setting("NORDRELAY_PEER_REQUIRE_TLS", "Require peer TLS", "Peers", "boolean", "Reject plaintext peer serving on non-loopback hosts.", true),
     setting("OPENAI_API_KEY", "OpenAI API key", "Voice", "secret", "Whisper fallback API key.", true),
     setting("VOICE_PREFERRED_BACKEND", "Voice backend", "Voice", "string", "auto, parakeet, faster-whisper, or openai.", false, ["auto", "parakeet", "faster-whisper", "openai"]),
     setting("VOICE_DEFAULT_LANGUAGE", "Voice language", "Voice", "string", "Default transcription language.", false),
@@ -243,6 +250,13 @@ const EXAMPLE_VALUES = {
     "NORDRELAY_UNIFIED_JOB_MAX_ITEMS": "1000",
     "NORDRELAY_VERSION_CACHE_TTL_MS": "3600000",
     "NORDRELAY_CLI_VERSION_CACHE_TTL_MS": "60000",
+    "NORDRELAY_PEER_ENABLED": "false",
+    "NORDRELAY_PEER_NAME": "",
+    "NORDRELAY_PEER_HOST": "127.0.0.1",
+    "NORDRELAY_PEER_PORT": "31979",
+    "NORDRELAY_PEER_PUBLIC_URL": "",
+    "NORDRELAY_PEER_TLS_ENABLED": "true",
+    "NORDRELAY_PEER_REQUIRE_TLS": "true",
     "NORDRELAY_DASHBOARD_HOST": "127.0.0.1",
     "NORDRELAY_DASHBOARD_PORT": "31878",
     "NORDRELAY_ENV_FILE": "",
@@ -271,6 +285,7 @@ const GROUP_INTROS = {
     Operations: "Runtime output, logging, update, and Telegram behavior controls.",
     Artifacts: "File, artifact, and retention controls.",
     Workspace: "State and workspace guardrails.",
+    Peers: "Optional NordRelay-to-NordRelay federation. Pairing is explicit, authenticated, scoped, and TLS-protected.",
     Voice: "Optional voice transcription settings.",
     Dashboard: "Local WebUI dashboard. User login is required for every page, API route, SSE stream, artifact download, and health endpoint.",
 };

package/dist/config.js

@@ -5,8 +5,9 @@ import { CLAUDE_CODE_EFFORT_LEVELS, HERMES_REASONING_EFFORTS, OPENCLAW_THINKING_
 import { parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
 export function loadConfig() {
     loadEnvFile(path.resolve(process.cwd(), ".env"));
-    const telegramEnabled = parseBooleanEnv(optionalString(process.env.TELEGRAM_ENABLED), true);
-    const telegramBotToken = telegramEnabled ? requireEnv("TELEGRAM_BOT_TOKEN") : "";
+    const adapterWarnings = [];
+    const requestedTelegramEnabled = parseBooleanEnv(optionalString(process.env.TELEGRAM_ENABLED), true);
+    const telegramBotToken = optionalString(process.env.TELEGRAM_BOT_TOKEN) ?? "";
     const telegramRateLimitMinIntervalMs = parseNonNegativeIntegerEnv(optionalString(process.env.TELEGRAM_RATE_LIMIT_MIN_INTERVAL_MS), 80, "TELEGRAM_RATE_LIMIT_MIN_INTERVAL_MS");
     const telegramEditMinIntervalMs = parseNonNegativeIntegerEnv(optionalString(process.env.TELEGRAM_EDIT_MIN_INTERVAL_MS), 1_200, "TELEGRAM_EDIT_MIN_INTERVAL_MS");
     const mirrorMode = parseMirrorMode(optionalString(process.env.NORDRELAY_CLI_MIRROR_MODE), "status");
@@ -25,7 +26,7 @@ export function loadConfig() {
     const telegramWebhookPort = parsePositiveIntegerEnv(optionalString(process.env.TELEGRAM_WEBHOOK_PORT), 8080, "TELEGRAM_WEBHOOK_PORT");
     const telegramWebhookPath = parseWebhookPath(optionalString(process.env.TELEGRAM_WEBHOOK_PATH));
     const telegramWebhookSecret = optionalString(process.env.TELEGRAM_WEBHOOK_SECRET);
-    const discordEnabled = parseBooleanEnv(optionalString(process.env.DISCORD_ENABLED), false);
+    const requestedDiscordEnabled = parseBooleanEnv(optionalString(process.env.DISCORD_ENABLED), false);
     const discordBotToken = optionalString(process.env.DISCORD_BOT_TOKEN);
     const discordClientId = optionalString(process.env.DISCORD_CLIENT_ID);
     const discordGuildIds = parseOptionalStringList(optionalString(process.env.DISCORD_GUILD_IDS));
@@ -108,16 +109,33 @@ export function loadConfig() {
     const sessionLockTtlMs = parseNonNegativeIntegerEnv(optionalString(process.env.NORDRELAY_SESSION_LOCK_TTL_MS), 30 * 60 * 1000, "NORDRELAY_SESSION_LOCK_TTL_MS");
     const dashboardCacheTtlMs = parseNonNegativeIntegerEnv(optionalString(process.env.NORDRELAY_DASHBOARD_CACHE_TTL_MS), 10_000, "NORDRELAY_DASHBOARD_CACHE_TTL_MS");
     const unifiedJobMaxItems = parsePositiveIntegerEnv(optionalString(process.env.NORDRELAY_UNIFIED_JOB_MAX_ITEMS), 1000, "NORDRELAY_UNIFIED_JOB_MAX_ITEMS");
+    const peerEnabled = parseBooleanEnv(optionalString(process.env.NORDRELAY_PEER_ENABLED), false);
+    const peerName = optionalString(process.env.NORDRELAY_PEER_NAME);
+    const peerHost = optionalString(process.env.NORDRELAY_PEER_HOST) ?? "127.0.0.1";
+    const peerPort = parsePositiveIntegerEnv(optionalString(process.env.NORDRELAY_PEER_PORT), 31979, "NORDRELAY_PEER_PORT");
+    const peerPublicUrl = optionalString(process.env.NORDRELAY_PEER_PUBLIC_URL);
+    const peerTlsEnabled = parseBooleanEnv(optionalString(process.env.NORDRELAY_PEER_TLS_ENABLED), true);
+    const peerRequireTls = parseBooleanEnv(optionalString(process.env.NORDRELAY_PEER_REQUIRE_TLS), true);
+    let telegramEnabled = requestedTelegramEnabled;
     if (telegramEnabled && telegramTransport === "webhook" && !telegramWebhookUrl) {
-        throw new Error("TELEGRAM_TRANSPORT=webhook requires TELEGRAM_WEBHOOK_URL");
+        telegramEnabled = false;
+        adapterWarnings.push("Telegram disabled: TELEGRAM_TRANSPORT=webhook requires TELEGRAM_WEBHOOK_URL.");
     }
+    if (telegramEnabled && !telegramBotToken) {
+        telegramEnabled = false;
+        adapterWarnings.push("Telegram disabled: TELEGRAM_BOT_TOKEN is missing.");
+    }
+    let discordEnabled = requestedDiscordEnabled;
     if (discordEnabled && !discordBotToken) {
-        throw new Error("DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN");
+        discordEnabled = false;
+        adapterWarnings.push("Discord disabled: DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN.");
     }
     if (!telegramEnabled && !discordEnabled) {
-        throw new Error("At least one chat adapter must be enabled.");
+        const detail = adapterWarnings.length > 0 ? ` ${adapterWarnings.join(" ")}` : "";
+        throw new Error(`At least one usable chat adapter must be enabled.${detail}`);
     }
     return {
+        adapterWarnings,
         telegramEnabled,
         telegramBotToken,
         telegramRateLimitMinIntervalMs,
@@ -220,6 +238,13 @@ export function loadConfig() {
         sessionLockTtlMs,
         dashboardCacheTtlMs,
         unifiedJobMaxItems,
+        peerEnabled,
+        peerName,
+        peerHost,
+        peerPort,
+        peerPublicUrl,
+        peerTlsEnabled,
+        peerRequireTls,
     };
 }
 /**

package/dist/context-key.js

@@ -1,3 +1,4 @@
+import { parsePeerRuntimeContextKey } from "./peer-context.js";
 export function telegramContextKeyFromMessage(chatId, messageThreadId) {
     if (messageThreadId !== undefined) {
         return `${chatId}:${messageThreadId}`;
@@ -111,6 +112,15 @@ export function parseChannelContextKey(key) {
             chatId: rawKey.slice("cli:".length) || "local",
         };
     }
+    const peer = parsePeerRuntimeContextKey(rawKey);
+    if (peer) {
+        return {
+            channelId: "peer",
+            contextKey: rawKey,
+            chatId: peer.peerId,
+            topicId: peer.sourceContextKey,
+        };
+    }
     return null;
 }
 export function channelIdForContextKey(key) {

package/dist/discord-bot.js

@@ -9,10 +9,12 @@ import { enabledAgents } from "./agent-factory.js";
 import { collectRecentWorkspaceArtifacts, ensureOutDir, formatArtifactSummary, persistWorkspaceArtifactReport } from "./artifacts.js";
 import { buildFileInstructions, outboxPath, stageFile } from "./attachments.js";
 import { AuditLogStore } from "./audit-log.js";
-import { BotPreferencesStore, parseMirrorMode, parseNotifyMode, parseVoiceBackendPreference } from "./bot-preferences.js";
+import { BotPreferencesStore } from "./bot-preferences.js";
 import { capabilitiesOf, filterActivityEvents, formatLocalDateTime, parseActivityOptions, renderExternalMirrorEvent, renderExternalMirrorStatus, renderPromptFailure, trimLine } from "./bot-rendering.js";
 import { renderAgentUpdateJobAction, renderAgentUpdateJobsAction, renderAgentUpdateLogAction, renderAgentUpdatePickerAction, renderQueueListAction } from "./channel-actions.js";
 import { ChannelCommandService } from "./channel-command-service.js";
+import { discordHelpCommandList } from "./channel-command-catalog.js";
+import { runChannelPeerPrompt } from "./channel-peer-prompt.js";
 import { deliverChannelAction } from "./channel-runtime.js";
 import { checkAuthStatus, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
 import { checkClaudeCodeAuthStatus, startClaudeCodeLogin, startClaudeCodeLogout } from "./claude-code-auth.js";
@@ -25,6 +27,7 @@ import { friendlyErrorText } from "./error-messages.js";
 import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
 import { spawnConnectorRestart, spawnSelfUpdate } from "./operations.js";
 import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
+import { RemoteRelayClient } from "./peer-client.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
 import { RelayArtifactService } from "./relay-artifact-service.js";
@@ -46,7 +49,8 @@ export function createDiscordBridge(config, registry) {
         return null;
     }
     if (!config.discordBotToken) {
-        throw new Error("DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN.");
+        console.warn("Discord adapter disabled: DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN.");
+        return null;
     }
     configureRedaction(config.telegramRedactPatterns);
     const intents = [
@@ -522,10 +526,44 @@ export function createDiscordBridge(config, registry) {
         await reply(request, `Session is locked by ${lock?.ownerLabel || lock?.ownerUserId || "another user"}.`);
         return true;
     };
+    const remoteClient = new RemoteRelayClient();
+    const handleRemotePrompt = async (request, envelope) => {
+        const targetPeerId = preferencesStore.get(request.contextKey).targetPeerId ?? undefined;
+        return runChannelPeerPrompt({
+            targetPeerId,
+            contextKey: request.contextKey,
+            prompt: envelope,
+            remoteClient,
+            editMinIntervalMs: EDIT_DEBOUNCE_MS,
+            typingIntervalMs: TYPING_INTERVAL_MS,
+            sendTyping: () => runtime.sendTyping(request.context),
+            sendResponse: async (text) => {
+                const rendered = trimDiscordMessage(text);
+                const sent = await runtime.sendMessage(request.context, { text: rendered, fallbackText: rendered });
+                return sent.messageId;
+            },
+            editResponse: async (messageId, text) => {
+                const rendered = trimDiscordMessage(text);
+                await runtime.editMessage(request.context, messageId, { text: rendered, fallbackText: rendered });
+            },
+            sendTurnStart: (remotePrompt) => reply(request, `Remote peer working on:\n${remotePrompt}`),
+            sendToolStart: (toolName) => reply(request, `Remote tool: ${toolName}`),
+            sendQueued: async (queueId) => {
+                await reply(request, `Remote prompt queued${queueId ? `: ${queueId}` : ""}.`, queueId ? {
+                    buttons: [[{ label: "Cancel queued message", action: `discord_peer_queue_cancel:${targetPeerId}:${queueId}` }]],
+                } : undefined);
+            },
+            sendCompleted: () => reply(request, "Remote turn completed."),
+            sendFailure: (message) => reply(request, `Remote peer failed: ${message}`),
+        });
+    };
     const handlePrompt = async (request, input, artifactOutDir, options = {}) => {
         const session = await getSession(request);
         const envelope = toPromptEnvelope(input, artifactOutDir);
         envelope.activityActor = actorFor(request);
+        if (!options.fromQueue && await handleRemotePrompt(request, envelope)) {
+            return;
+        }
         if (!options.fromQueue && await denyIfLocked(request)) {
             return;
         }
@@ -893,6 +931,17 @@ export function createDiscordBridge(config, registry) {
             case "channels":
                 await deliverChannelAction(runtime, request.context, commandService.renderChannels());
                 return;
+            case "peers":
+                await deliverChannelAction(runtime, request.context, commandService.renderPeers());
+                return;
+            case "target":
+                await deliverChannelAction(runtime, request.context, commandService.renderTargetPreference({
+                    source: "discord",
+                    contextKey: request.contextKey,
+                    argument,
+                    preferencesStore,
+                }));
+                return;
             case "agents":
                 await deliverChannelAction(runtime, request.context, commandService.renderAgents());
                 return;
@@ -1046,7 +1095,7 @@ export function createDiscordBridge(config, registry) {
             "",
             "Send a message to prompt the selected agent, or use slash commands.",
             "",
-            "Core commands: `/agent`, `/agents`, `/auth`, `/login`, `/logout`, `/session`, `/sessions`, `/new`, `/switch`, `/attach`, `/handback`, `/workspaces`, `/pin`, `/unpin`, `/pinned`, `/model`, `/reasoning`, `/fast`, `/launch`, `/launch_profiles`, `/queue`, `/clearqueue`, `/cancel`, `/stop`, `/retry`, `/sync`, `/progress`, `/activity`, `/audit`, `/artifacts`, `/logs`, `/version`, `/diagnostics`, `/support`, `/restart`, `/update`, `/lock`, `/unlock`, `/locks`, `/mirror`, `/notify`, `/voice`, `/channels`, `/whoami`, `/link`, `/register_channel`.",
+            `Core commands: ${discordHelpCommandList()}.`,
             "",
             renderSessionInfoPlain(session.getInfo()),
         ].join("\n"));
@@ -1595,33 +1644,32 @@ export function createDiscordBridge(config, registry) {
         await deliverChannelAction(runtime, request.context, commandService.renderHandback(result));
     };
     const commandMirror = async (request, argument) => {
-        const mode = parseMirrorMode(argument, preferencesStore.get(request.contextKey).mirrorMode ?? config.discordMirrorMode);
-        preferencesStore.update(request.contextKey, { mirrorMode: mode });
-        await reply(request, `CLI mirror mode: ${mode}`);
+        const session = await getSession(request, { deferThreadStart: true });
+        const info = session.getInfo();
+        await deliverChannelAction(runtime, request.context, commandService.renderMirrorPreference({
+            source: "discord",
+            contextKey: request.contextKey,
+            argument,
+            preferencesStore,
+            cliMirrorSupported: capabilitiesOf(info).cliMirror,
+            agentLabel: info.agentLabel,
+        }));
     };
     const commandNotify = async (request, argument) => {
-        const mode = parseNotifyMode(argument, preferencesStore.get(request.contextKey).notifyMode ?? config.discordNotifyMode);
-        preferencesStore.update(request.contextKey, { notifyMode: mode });
-        await reply(request, `Notify mode: ${mode}`);
+        await deliverChannelAction(runtime, request.context, commandService.renderNotifyPreference({
+            source: "discord",
+            contextKey: request.contextKey,
+            argument,
+            preferencesStore,
+        }));
     };
     const commandVoice = async (request, argument) => {
-        const normalized = argument.trim().toLowerCase();
-        const parts = normalized.split(/\s+/).filter(Boolean);
-        if (parts[0] === "backend" && parts[1]) {
-            preferencesStore.update(request.contextKey, { voiceBackend: parseVoiceBackendPreference(parts[1]) });
-        }
-        else if (parts[0] === "language" && parts[1]) {
-            preferencesStore.update(request.contextKey, { voiceLanguage: parts[1] === "auto" ? null : parts[1] });
-        }
-        else if ((parts[0] === "transcribe-only" || parts[0] === "transcribe_only") && parts[1]) {
-            preferencesStore.update(request.contextKey, { voiceTranscribeOnly: ["on", "true", "yes", "1"].includes(parts[1]) });
-        }
-        else if (argument.trim()) {
-            await reply(request, "Usage: `/voice`, `/voice backend auto|parakeet|faster-whisper|openai`, `/voice language auto|<code>`, or `/voice transcribe_only on|off`.");
-            return;
-        }
-        const prefs = preferencesStore.get(request.contextKey);
-        await reply(request, `Voice backend: ${prefs.voiceBackend ?? config.voicePreferredBackend}\nLanguage: ${prefs.voiceLanguage ?? config.voiceDefaultLanguage ?? "auto"}\nTranscribe only: ${prefs.voiceTranscribeOnly ?? config.voiceTranscribeOnly}`);
+        await deliverChannelAction(runtime, request.context, await commandService.renderVoicePreference({
+            source: "discord",
+            contextKey: request.contextKey,
+            argument,
+            preferencesStore,
+        }));
     };
     const commandRegisterChannel = async (request) => {
         const channel = userStore.registerDiscordChannel({
@@ -1781,6 +1829,17 @@ export function createDiscordBridge(config, registry) {
             await commandQueue(request, `${queueMatch[1]} ${queueMatch[3]}`);
             return;
         }
+        const peerQueueMatch = action.match(/^discord_peer_queue_cancel:([^:]+):([^:]+)$/);
+        if (peerQueueMatch?.[1] && peerQueueMatch[2]) {
+            await remoteClient.webProxy(peerQueueMatch[1], {
+                method: "POST",
+                path: "/api/queue",
+                body: { action: "cancel", id: peerQueueMatch[2] },
+                contextKey: request.contextKey,
+            }, actorFor(request), request.contextKey);
+            await reply(request, `Cancelled remote queued prompt ${peerQueueMatch[2]}.`, { ephemeral: true });
+            return;
+        }
         const artifactMatch = action.match(/^discord_artifact_(send|zip|delete):(.+):([^:]+)$/);
         if (artifactMatch?.[1] && artifactMatch[2] === request.contextKey) {
             await commandArtifacts(request, `${artifactMatch[1]} ${artifactMatch[3]}`);