@nordbyte/nordrelay 0.5.1 → 0.6.0

package/dist/channel-actions.js

@@ -7,7 +7,9 @@ export function renderChannelsAction(descriptors) {
     const plain = [
         "Channel adapters:",
         ...descriptors.map((descriptor) => {
-            const status = descriptor.status === "available" ? "available" : "planned";
+            const status = descriptor.status === "available"
+                ? descriptor.enabled === false ? "available / disabled" : "available / enabled"
+                : "planned";
             return `${descriptor.label}: ${status} · ${descriptor.capabilities.join(", ")}`;
         }),
     ].join("\n");
@@ -15,8 +17,11 @@ export function renderChannelsAction(descriptors) {
         "<b>Channel adapters:</b>",
         ...descriptors.map((descriptor) => {
             const statusIcon = descriptor.status === "available" ? "✅" : "🟡";
+            const status = descriptor.status === "available"
+                ? descriptor.enabled === false ? "available / disabled" : "available / enabled"
+                : descriptor.status;
             const notes = descriptor.notes ? `\n  ${escapeHTML(descriptor.notes)}` : "";
-            return `${statusIcon} <b>${escapeHTML(descriptor.label)}</b> <code>${escapeHTML(descriptor.status)}</code>\n  <code>${escapeHTML(descriptor.capabilities.join(", "))}</code>${notes}`;
+            return `${statusIcon} <b>${escapeHTML(descriptor.label)}</b> <code>${escapeHTML(status)}</code>\n  <code>${escapeHTML(descriptor.capabilities.join(", "))}</code>${notes}`;
         }),
     ].join("\n");
     return { plain, html };

package/dist/channel-adapter.js

@@ -9,14 +9,17 @@ const TELEGRAM_CAPABILITIES = [
     "topics",
     "webhooks",
 ];
+const DISCORD_CAPABILITIES = [
+    "text",
+    "streaming-edits",
+    "typing",
+    "inline-buttons",
+    "files",
+    "photos",
+    "voice",
+    "topics",
+];
 const PLANNED_CHANNELS = [
-    {
-        id: "discord",
-        label: "Discord",
-        capabilities: ["text", "streaming-edits", "typing", "inline-buttons", "files", "photos", "voice"],
-        status: "planned",
-        notes: "Adapter boundary is ready; runtime integration still needs bot credentials and event mapping.",
-    },
     {
         id: "whatsapp",
         label: "WhatsApp",
@@ -42,17 +45,41 @@ export class TelegramChannelAdapter {
     label = "Telegram";
     capabilities = new Set(TELEGRAM_CAPABILITIES);
     describe() {
+        const enabled = process.env.TELEGRAM_ENABLED !== "false";
+        return {
+            id: this.id,
+            label: this.label,
+            capabilities: [...this.capabilities],
+            status: "available",
+            enabled,
+            notes: enabled
+                ? "Telegram bot runtime is enabled by default."
+                : "Telegram bot runtime is disabled.",
+        };
+    }
+}
+export class DiscordChannelAdapter {
+    id = "discord";
+    label = "Discord";
+    capabilities = new Set(DISCORD_CAPABILITIES);
+    describe() {
+        const enabled = process.env.DISCORD_ENABLED === "true";
         return {
             id: this.id,
             label: this.label,
             capabilities: [...this.capabilities],
             status: "available",
+            enabled,
+            notes: enabled
+                ? "Discord bot runtime is enabled."
+                : "Enable with DISCORD_ENABLED=true and DISCORD_BOT_TOKEN.",
         };
     }
 }
 export function listChannelDescriptors() {
     return [
         new TelegramChannelAdapter().describe(),
+        new DiscordChannelAdapter().describe(),
         ...PLANNED_CHANNELS,
     ];
 }

package/dist/channel-command-service.js

@@ -0,0 +1,156 @@
+import { listAgentAdapterDescriptors } from "./agent-adapter.js";
+import { enabledAgents } from "./agent-factory.js";
+import { logTailRequests, parseLogsCommand, renderAgentsAction, renderChannelsAction, renderLogTailsAction, } from "./channel-actions.js";
+import { listChannelDescriptors } from "./channel-adapter.js";
+import { escapeHTML } from "./format.js";
+import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, } from "./operations.js";
+import { formatCliPathHTML, formatCliPathPlain, renderActivityTimeline, renderAuditEvents, renderProgressHTML, renderProgressPlain, renderVersionCheckHTML, renderVersionCheckPlain, } from "./bot-rendering.js";
+import { renderSessionInfoHTML, renderSessionInfoPlain } from "./session-format.js";
+export class ChannelCommandService {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    renderChannels() {
+        return renderChannelsAction(listChannelDescriptors());
+    }
+    renderAgents(agentIds = enabledAgents(this.config)) {
+        return renderAgentsAction(listAgentAdapterDescriptors(), agentIds);
+    }
+    async renderLogs(argument) {
+        const logRequest = parseLogsCommand(argument);
+        const logs = await Promise.all(logTailRequests(logRequest.target).map(async (request) => ({
+            title: request.title,
+            tail: await readFormattedLogTail(logRequest.lines, request.path),
+        })));
+        return renderLogTailsAction(logs);
+    }
+    async renderVersion() {
+        const health = await getConnectorHealth(cliPathOptions(this.config));
+        const state = await readConnectorState();
+        const versions = await getVersionChecks(cliPathOptions(this.config));
+        const plain = [
+            renderVersionCheckPlain(versions.nordrelay),
+            `Runtime status: ${state.status ?? "unknown"}`,
+            formatCliPathPlain("Codex CLI", health.codexCliPath, health.codexCli),
+            renderVersionCheckPlain(versions.codex),
+            formatCliPathPlain("Pi CLI", health.piCliPath, health.piCli),
+            renderVersionCheckPlain(versions.pi),
+            formatCliPathPlain("Hermes CLI", health.hermesCliPath, health.hermesCli),
+            renderVersionCheckPlain(versions.hermes),
+            formatCliPathPlain("OpenClaw CLI", health.openClawCliPath, health.openClawCli),
+            renderVersionCheckPlain(versions.openclaw),
+            formatCliPathPlain("Claude Code CLI", health.claudeCodeCliPath, health.claudeCodeCli),
+            renderVersionCheckPlain(versions.claudeCode),
+        ].join("\n");
+        const html = [
+            renderVersionCheckHTML(versions.nordrelay),
+            `<b>Runtime status:</b> <code>${escapeHTML(state.status ?? "unknown")}</code>`,
+            formatCliPathHTML("Codex CLI", health.codexCliPath, health.codexCli),
+            renderVersionCheckHTML(versions.codex),
+            formatCliPathHTML("Pi CLI", health.piCliPath, health.piCli),
+            renderVersionCheckHTML(versions.pi),
+            formatCliPathHTML("Hermes CLI", health.hermesCliPath, health.hermesCli),
+            renderVersionCheckHTML(versions.hermes),
+            formatCliPathHTML("OpenClaw CLI", health.openClawCliPath, health.openClawCli),
+            renderVersionCheckHTML(versions.openclaw),
+            formatCliPathHTML("Claude Code CLI", health.claudeCodeCliPath, health.claudeCodeCli),
+            renderVersionCheckHTML(versions.claudeCode),
+        ].join("\n");
+        return { plain, html };
+    }
+    renderAuthStatus(status) {
+        const icon = status.authenticated ? "✅" : "❌";
+        return {
+            plain: [
+                `${icon} ${status.label} auth: ${status.authenticated ? "authenticated" : "not authenticated"}`,
+                `Method: ${status.method ?? "-"}`,
+                `Detail: ${status.detail}`,
+            ].join("\n"),
+            html: [
+                `<b>${icon} ${escapeHTML(status.label)} auth:</b> <code>${status.authenticated ? "authenticated" : "not authenticated"}</code>`,
+                `<b>Method:</b> <code>${escapeHTML(status.method ?? "-")}</code>`,
+                `<b>Detail:</b> <code>${escapeHTML(status.detail)}</code>`,
+            ].join("\n"),
+        };
+    }
+    renderAuthActionResult(action, result) {
+        const label = action === "login" ? "Login" : "Logout";
+        const icon = result.success ? "✅" : "❌";
+        return {
+            plain: [`${icon} ${label} ${result.success ? "started" : "failed"}.`, "", result.message].join("\n"),
+            html: [`<b>${icon} ${escapeHTML(label)} ${result.success ? "started" : "failed"}.</b>`, "", `<code>${escapeHTML(result.message)}</code>`].join("\n"),
+        };
+    }
+    renderHostAuthInstruction(label, command, action) {
+        const text = `${label} ${action} is not managed remotely. Run this on the host: ${command}`;
+        return {
+            plain: text,
+            html: `<b>${escapeHTML(label)} ${escapeHTML(action)} is not managed remotely.</b>\nRun this on the host:\n<code>${escapeHTML(command)}</code>`,
+        };
+    }
+    renderProgress(progress, queueLength, busyState, info) {
+        return {
+            plain: renderProgressPlain(progress, queueLength, busyState, info),
+            html: renderProgressHTML(progress, queueLength, busyState, info),
+        };
+    }
+    renderActivity(threadId, events, options) {
+        return renderActivityTimeline(threadId, events, options);
+    }
+    renderAudit(events) {
+        return renderAuditEvents(events);
+    }
+    renderWorkspaces(info, workspaces) {
+        const unique = [...new Set(workspaces)].filter(Boolean);
+        const rows = unique.length > 0
+            ? unique.map((workspace, index) => `${index + 1}. ${workspace}${workspace === info.workspace ? " (current)" : ""}`)
+            : [`No workspaces found in ${info.agentLabel} state.`];
+        return {
+            plain: [`${info.agentLabel} workspaces:`, ...rows].join("\n"),
+            html: [
+                `<b>${escapeHTML(info.agentLabel)} workspaces:</b>`,
+                ...rows.map((line) => `<code>${escapeHTML(line)}</code>`),
+            ].join("\n"),
+        };
+    }
+    renderHandback(result) {
+        const command = result.command ?? (result.threadId
+            ? `cd ${shellEscape(result.workspace)} && codex resume ${shellEscape(result.threadId)}`
+            : "");
+        if (!result.threadId || !command) {
+            const text = "This thread has not started yet, so there is no resumable thread ID. Send a message to create one, or start a new session.";
+            return { plain: text, html: escapeHTML(text) };
+        }
+        const label = result.label ?? "Agent CLI";
+        return {
+            plain: [
+                `Thread handed back to ${label}.`,
+                "",
+                "Run this in your terminal:",
+                command,
+                "",
+                "Send any message here to start a new NordRelay thread.",
+            ].join("\n"),
+            html: [
+                `<b>Thread handed back to ${escapeHTML(label)}.</b>`,
+                "",
+                "Run this in your terminal:",
+                `<pre>${escapeHTML(command)}</pre>`,
+                "",
+                "Send any message here to start a new NordRelay thread.",
+            ].join("\n"),
+        };
+    }
+}
+export function cliPathOptions(config) {
+    return {
+        piCliPath: config.piCliPath,
+        hermesCliPath: config.hermesCliPath,
+        openClawCliPath: config.openClawCliPath,
+        claudeCodeCliPath: config.claudeCodeCliPath,
+    };
+}
+function shellEscape(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/channel-turn-service.js

@@ -0,0 +1,237 @@
+import { randomUUID } from "node:crypto";
+import { CODEX_AGENT_CAPABILITIES, agentLabel, } from "./agent.js";
+import { friendlyErrorText } from "./error-messages.js";
+export class ChannelTurnService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async run(session, envelope) {
+        const actor = envelope.activityActor;
+        await this.options.ensureActiveThread(session);
+        const info = session.getInfo();
+        if ((info.capabilities ?? CODEX_AGENT_CAPABILITIES).auth) {
+            const auth = await this.options.checkAuth(info);
+            if (!auth.authenticated) {
+                throw new Error(`${agentLabel(info.agentId)} is not authenticated: ${auth.detail}`);
+            }
+        }
+        const turnId = randomUUID().slice(0, 12);
+        const startedMs = Date.now();
+        this.options.setCurrentTurn(turnId, startedMs, "");
+        this.options.setCurrentProgress({
+            id: turnId,
+            source: this.options.source,
+            status: "running",
+            prompt: envelope.description,
+            agentId: info.agentId,
+            agentLabel: info.agentLabel,
+            threadId: info.threadId,
+            workspace: info.workspace,
+            startedAt: new Date(startedMs).toISOString(),
+            updatedAt: new Date(startedMs).toISOString(),
+            durationMs: 0,
+            outputChars: 0,
+            tools: [],
+        });
+        this.options.setLastPrompt(envelope);
+        const startedDate = new Date();
+        const startedAt = startedDate.toISOString();
+        this.options.chatStore.append({
+            threadId: info.threadId ?? "pending",
+            role: "user",
+            text: envelope.description,
+            source: this.options.source,
+            turnId,
+            timestamp: startedAt,
+        });
+        this.options.appendActivity({
+            source: this.options.source,
+            status: "running",
+            type: "prompt_started",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor,
+            prompt: envelope.description,
+        });
+        this.options.appendAudit({
+            action: "prompt_started",
+            status: "ok",
+            contextKey: this.options.contextKey,
+            agentId: info.agentId,
+            threadId: info.threadId,
+            workspace: info.workspace,
+            actor,
+            description: envelope.description,
+        });
+        this.options.broadcast({ type: "turn_start", id: turnId, prompt: envelope.description, at: startedAt, source: this.options.source });
+        try {
+            await session.prompt(envelope.input, this.callbacks(turnId, info, envelope, actor));
+            this.options.updateSession(session);
+            await this.options.artifactService.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, turnId, startedDate);
+            const text = this.options.getAccumulatedText();
+            if (text.trim()) {
+                this.options.chatStore.append({
+                    threadId: info.threadId ?? "pending",
+                    role: "agent",
+                    text,
+                    source: this.options.source,
+                    turnId,
+                });
+            }
+            this.options.appendActivity({
+                source: this.options.source,
+                status: "completed",
+                type: "prompt_completed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                actor,
+                prompt: envelope.description,
+                durationMs: Date.now() - this.options.getCurrentTurnStartedAt(),
+            });
+            this.options.appendAudit({
+                action: "prompt_completed",
+                status: "ok",
+                contextKey: this.options.contextKey,
+                agentId: info.agentId,
+                threadId: info.threadId,
+                workspace: info.workspace,
+                actor,
+                description: envelope.description,
+            });
+            this.updateCurrentProgress({ status: "completed" });
+            this.options.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() });
+            this.options.broadcast({ type: "chat_history", messages: await this.options.chatHistory() });
+        }
+        catch (error) {
+            const errorText = friendlyErrorText(error);
+            this.options.chatStore.append({
+                threadId: info.threadId ?? "pending",
+                role: "system",
+                text: `Error: ${errorText}`,
+                source: this.options.source,
+                turnId,
+            });
+            this.options.appendActivity({
+                source: this.options.source,
+                status: "failed",
+                type: "prompt_failed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                actor,
+                prompt: envelope.description,
+                detail: errorText,
+                durationMs: Date.now() - this.options.getCurrentTurnStartedAt(),
+            });
+            this.options.appendAudit({
+                action: "prompt_failed",
+                status: "failed",
+                contextKey: this.options.contextKey,
+                agentId: info.agentId,
+                threadId: info.threadId,
+                workspace: info.workspace,
+                actor,
+                description: envelope.description,
+                detail: errorText,
+            });
+            this.updateCurrentProgress({ status: "failed", detail: errorText });
+            this.options.broadcast({ type: "turn_error", id: turnId, error: errorText, at: new Date().toISOString() });
+            this.options.broadcast({ type: "chat_history", messages: await this.options.chatHistory() });
+            throw error;
+        }
+        finally {
+            const progress = this.options.getCurrentProgress();
+            if (progress) {
+                progress.durationMs = Date.now() - this.options.getCurrentTurnStartedAt();
+                progress.updatedAt = new Date().toISOString();
+            }
+            this.options.setCurrentTurn(null);
+        }
+    }
+    callbacks(turnId, info, envelope, actor) {
+        return {
+            onTextDelta: (delta) => {
+                const nextText = this.options.getAccumulatedText() + delta;
+                this.options.setAccumulatedText(nextText);
+                this.updateCurrentProgress({ outputChars: nextText.length });
+                this.options.broadcast({ type: "text_delta", id: turnId, delta });
+            },
+            onToolStart: (toolName, toolCallId) => {
+                this.addCurrentTool(toolName);
+                this.options.appendActivity({
+                    source: this.options.source,
+                    status: "running",
+                    type: "tool_started",
+                    threadId: info.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor,
+                    prompt: envelope.description,
+                    detail: toolName,
+                });
+                this.options.broadcast({ type: "tool_start", id: turnId, toolCallId, toolName });
+            },
+            onToolUpdate: (toolCallId, partialResult) => {
+                this.updateCurrentProgress();
+                this.options.broadcast({ type: "tool_update", id: turnId, toolCallId, partialResult });
+            },
+            onToolEnd: (toolCallId, isError) => {
+                const progress = this.options.getCurrentProgress();
+                const toolName = progress?.currentTool ?? progress?.lastTool ?? toolCallId;
+                this.updateCurrentProgress({ currentTool: undefined });
+                this.options.appendActivity({
+                    source: this.options.source,
+                    status: isError ? "failed" : "completed",
+                    type: isError ? "tool_failed" : "tool_completed",
+                    threadId: info.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor,
+                    prompt: envelope.description,
+                    detail: toolName,
+                });
+                this.options.broadcast({ type: "tool_end", id: turnId, toolCallId, isError });
+            },
+            onTodoUpdate: (items) => {
+                this.updateCurrentProgress({ detail: `Plan: ${items.filter((item) => item.completed).length}/${items.length} done` });
+                this.options.broadcast({ type: "todo_update", id: turnId, items });
+            },
+            onTurnComplete: () => { },
+            onAgentEnd: () => this.options.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() }),
+        };
+    }
+    updateCurrentProgress(patch = {}) {
+        const progress = this.options.getCurrentProgress();
+        if (!progress) {
+            return;
+        }
+        if ("currentTool" in patch) {
+            progress.currentTool = patch.currentTool;
+            const { currentTool: _currentTool, ...rest } = patch;
+            Object.assign(progress, rest);
+        }
+        else {
+            Object.assign(progress, patch);
+        }
+        progress.durationMs = Date.now() - this.options.getCurrentTurnStartedAt();
+        progress.updatedAt = new Date().toISOString();
+        this.options.setCurrentProgress(progress);
+    }
+    addCurrentTool(toolName) {
+        const progress = this.options.getCurrentProgress();
+        if (!progress) {
+            return;
+        }
+        const existing = progress.tools.find((tool) => tool.name === toolName);
+        if (existing) {
+            existing.count += 1;
+        }
+        else {
+            progress.tools.push({ name: toolName, count: 1 });
+        }
+        this.updateCurrentProgress({ currentTool: toolName, lastTool: toolName });
+    }
+}

package/dist/codex-cli.js

@@ -26,7 +26,7 @@ export function findExecutableOnPath(command, pathValue) {
         return undefined;
     }
     const extensions = process.platform === "win32"
-        ? (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";")
+        ? ["", ...(process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";")]
         : [""];
     for (const rawDirectory of pathValue.split(path.delimiter)) {
         const directory = rawDirectory.trim();