@nordbyte/nordrelay 0.3.1 → 0.4.1

package/dist/session-format.js

@@ -17,13 +17,27 @@ export function renderSessionInfoPlain(info) {
         capabilities.fastMode
             ? `Reasoning/Fast: ${info.reasoningEffort ?? "(model default)"} / ${info.fastMode ? "on" : "off"}`
             : `${agentReasoningLabel(agentId)}: ${info.reasoningEffort ?? "(model default)"}`,
-        ...renderCodexUsagePlain(info),
-        ...renderAgentUsagePlain(info),
-        info.sessionTokens ? formatSessionTokensPlain(info.sessionTokens) : undefined,
+        ...renderSessionUsageRowsPlain(info),
     ]
         .filter((line) => Boolean(line))
         .join("\n");
 }
+export function renderSessionUsageRowsPlain(info) {
+    const capabilities = info.capabilities ?? CODEX_AGENT_CAPABILITIES;
+    return [
+        ...renderCodexUsagePlain(info, capabilities),
+        ...renderAgentUsagePlain(info, capabilities),
+        info.sessionTokens ? formatSessionTokensPlain(info.sessionTokens) : undefined,
+    ].filter((line) => Boolean(line));
+}
+export function renderSessionUsageRows(info) {
+    const capabilities = info.capabilities ?? CODEX_AGENT_CAPABILITIES;
+    return [
+        ...renderCodexUsageRows(info, capabilities),
+        ...renderAgentUsageRows(info, capabilities),
+        info.sessionTokens ? ["Session tokens", formatSessionTokensValue(info.sessionTokens)] : undefined,
+    ].filter((row) => Boolean(row));
+}
 export function renderSessionInfoHTML(info) {
     const capabilities = info.capabilities ?? CODEX_AGENT_CAPABILITIES;
     const agentId = info.agentId ?? "codex";
@@ -42,8 +56,8 @@ export function renderSessionInfoHTML(info) {
         capabilities.fastMode
             ? `<b>Reasoning/Fast:</b> <code>${escapeHTML(info.reasoningEffort ?? "(model default)")} / ${info.fastMode ? "on" : "off"}</code>`
             : `<b>${escapeHTML(agentReasoningLabel(agentId))}:</b> <code>${escapeHTML(info.reasoningEffort ?? "(model default)")}</code>`,
-        ...renderCodexUsageHTML(info),
-        ...renderAgentUsageHTML(info),
+        ...renderCodexUsageHTML(info, capabilities),
+        ...renderAgentUsageHTML(info, capabilities),
         info.sessionTokens ? `<b>Session tokens:</b> <code>${escapeHTML(formatSessionTokensValue(info.sessionTokens))}</code>` : undefined,
     ]
         .filter((line) => Boolean(line))
@@ -67,16 +81,16 @@ export function formatFileSize(bytes) {
     }
     return `${(bytes / (1024 * 1024)).toFixed(1).replace(/\.0$/, "")} MB`;
 }
-function renderCodexUsagePlain(info) {
+function renderCodexUsagePlain(info, capabilities) {
     const usage = info.codexUsage;
     if (!usage) {
         return [];
     }
     const lines = [];
-    if (usage.contextUsedPercent !== null && usage.contextWindow !== null && usage.lastTokenUsage) {
+    if (capabilities.usageStats && usage.contextUsedPercent !== null && usage.contextWindow !== null && usage.lastTokenUsage) {
         lines.push(`Context used: ${formatPercent(usage.contextUsedPercent)} (${formatCompactTokenCount(usage.lastTokenUsage.totalTokens)} / ${formatCompactTokenCount(usage.contextWindow)})`);
     }
-    if (usage.totalTokenUsage) {
+    if (capabilities.usageStats && usage.totalTokenUsage) {
         lines.push([
             `Tokens in: ${formatCompactTokenCount(usage.totalTokenUsage.inputTokens)}`,
             `cached: ${formatCompactTokenCount(usage.totalTokenUsage.cachedInputTokens)}`,
@@ -84,22 +98,24 @@ function renderCodexUsagePlain(info) {
             `reasoning out: ${formatCompactTokenCount(usage.totalTokenUsage.reasoningOutputTokens)}`,
         ].join(" · "));
     }
-    const limits = formatLimitsLeft(usage);
-    if (limits) {
-        lines.push(`Limits left: ${limits}`);
+    if (capabilities.subscriptionLimits) {
+        const limits = formatLimitsLeft(usage);
+        if (limits) {
+            lines.push(`Limits left: ${limits}`);
+        }
     }
     return lines;
 }
-function renderCodexUsageHTML(info) {
+function renderCodexUsageHTML(info, capabilities) {
     const usage = info.codexUsage;
     if (!usage) {
         return [];
     }
     const lines = [];
-    if (usage.contextUsedPercent !== null && usage.contextWindow !== null && usage.lastTokenUsage) {
+    if (capabilities.usageStats && usage.contextUsedPercent !== null && usage.contextWindow !== null && usage.lastTokenUsage) {
         lines.push(`<b>Context used:</b> <code>${escapeHTML(formatPercent(usage.contextUsedPercent))}</code> <i>(${escapeHTML(formatCompactTokenCount(usage.lastTokenUsage.totalTokens))} / ${escapeHTML(formatCompactTokenCount(usage.contextWindow))})</i>`);
     }
-    if (usage.totalTokenUsage) {
+    if (capabilities.usageStats && usage.totalTokenUsage) {
         lines.push(`<b>Tokens:</b> <code>${escapeHTML([
             `in ${formatCompactTokenCount(usage.totalTokenUsage.inputTokens)}`,
             `cached ${formatCompactTokenCount(usage.totalTokenUsage.cachedInputTokens)}`,
@@ -107,13 +123,49 @@ function renderCodexUsageHTML(info) {
             `reasoning out ${formatCompactTokenCount(usage.totalTokenUsage.reasoningOutputTokens)}`,
         ].join(" · "))}</code>`);
     }
-    const limits = formatLimitsLeft(usage);
-    if (limits) {
-        lines.push(`<b>Limits left:</b> <code>${escapeHTML(limits)}</code>`);
+    if (capabilities.subscriptionLimits) {
+        const limits = formatLimitsLeft(usage);
+        if (limits) {
+            lines.push(`<b>Limits left:</b> <code>${escapeHTML(limits)}</code>`);
+        }
     }
     return lines;
 }
-function renderAgentUsagePlain(info) {
+function renderCodexUsageRows(info, capabilities) {
+    const usage = info.codexUsage;
+    if (!usage) {
+        return [];
+    }
+    const rows = [];
+    if (capabilities.usageStats && usage.contextUsedPercent !== null && usage.contextWindow !== null && usage.lastTokenUsage) {
+        rows.push([
+            "Context used",
+            `${formatPercent(usage.contextUsedPercent)} (${formatCompactTokenCount(usage.lastTokenUsage.totalTokens)} / ${formatCompactTokenCount(usage.contextWindow)})`,
+        ]);
+    }
+    if (capabilities.usageStats && usage.totalTokenUsage) {
+        rows.push([
+            "Tokens",
+            [
+                `in ${formatCompactTokenCount(usage.totalTokenUsage.inputTokens)}`,
+                `cached ${formatCompactTokenCount(usage.totalTokenUsage.cachedInputTokens)}`,
+                `out ${formatCompactTokenCount(usage.totalTokenUsage.outputTokens)}`,
+                `reasoning out ${formatCompactTokenCount(usage.totalTokenUsage.reasoningOutputTokens)}`,
+            ].join(" · "),
+        ]);
+    }
+    if (capabilities.subscriptionLimits) {
+        const limits = formatLimitsLeft(usage);
+        if (limits) {
+            rows.push(["Limits left", limits]);
+        }
+    }
+    return rows;
+}
+function renderAgentUsagePlain(info, capabilities) {
+    if (!capabilities.usageStats) {
+        return [];
+    }
     const lines = [];
     if (info.contextUsage?.percent !== undefined && info.contextUsage.percent !== null) {
         const contextWindow = info.contextUsage.contextWindow !== null && info.contextUsage.contextWindow !== undefined
@@ -131,7 +183,10 @@ function renderAgentUsagePlain(info) {
     }
     return lines;
 }
-function renderAgentUsageHTML(info) {
+function renderAgentUsageHTML(info, capabilities) {
+    if (!capabilities.usageStats) {
+        return [];
+    }
     const lines = [];
     if (info.contextUsage?.percent !== undefined && info.contextUsage.percent !== null) {
         const contextWindow = info.contextUsage.contextWindow !== null && info.contextUsage.contextWindow !== undefined
@@ -149,6 +204,30 @@ function renderAgentUsageHTML(info) {
     }
     return lines;
 }
+function renderAgentUsageRows(info, capabilities) {
+    if (!capabilities.usageStats) {
+        return [];
+    }
+    const rows = [];
+    if (info.contextUsage?.percent !== undefined && info.contextUsage.percent !== null) {
+        const contextWindow = info.contextUsage.contextWindow !== null && info.contextUsage.contextWindow !== undefined
+            ? ` (${formatCompactTokenCount(info.contextUsage.tokens ?? 0)} / ${formatCompactTokenCount(info.contextUsage.contextWindow)})`
+            : "";
+        rows.push(["Context used", `${formatPercent(info.contextUsage.percent)}${contextWindow}`]);
+    }
+    if (info.sessionUsage) {
+        rows.push([
+            "Tokens",
+            [
+                `in ${formatCompactTokenCount(info.sessionUsage.input)}`,
+                `cache read ${formatCompactTokenCount(info.sessionUsage.cacheRead)}`,
+                `cache write ${formatCompactTokenCount(info.sessionUsage.cacheWrite)}`,
+                `out ${formatCompactTokenCount(info.sessionUsage.output)}`,
+            ].join(" · "),
+        ]);
+    }
+    return rows;
+}
 function formatLimitsLeft(usage) {
     const parts = [];
     if (usage.rateLimits?.primary) {

package/dist/session-registry.js

@@ -64,7 +64,7 @@ export class SessionRegistry {
             agentId,
             threadId: null,
             workspace: previous?.workspace ?? this.config.workspace,
-            pinnedThreadIds: previous?.pinnedThreadIds,
+            pinnedThreadIdsByAgent: previous?.pinnedThreadIdsByAgent,
             updatedAt: Date.now(),
         };
         this.metadata.set(contextKey, next);
@@ -74,9 +74,12 @@ export class SessionRegistry {
     updateMetadata(contextKey, session) {
         const info = session.getInfo();
         const previous = this.metadata.get(contextKey);
-        const pinnedThreadIds = previous?.pinnedThreadIds ?? [];
+        const agentId = info.agentId ?? "codex";
+        const previousPinnedByAgent = previous?.pinnedThreadIdsByAgent ?? {};
+        const pinnedThreadIds = previousPinnedByAgent[agentId] ?? previous?.pinnedThreadIds ?? [];
         const next = {
             contextKey,
+            agentId,
             threadId: info.threadId,
             workspace: info.workspace,
             model: info.model,
@@ -84,49 +87,64 @@ export class SessionRegistry {
             launchProfileId: info.nextLaunchProfileId ?? info.launchProfileId,
             updatedAt: Date.now(),
         };
-        if (info.agentId && info.agentId !== "codex") {
-            next.agentId = info.agentId;
-        }
         if (info.sessionPath) {
             next.sessionPath = info.sessionPath;
         }
+        const nextPinnedByAgent = { ...previousPinnedByAgent };
         if (pinnedThreadIds.length > 0) {
-            next.pinnedThreadIds = pinnedThreadIds;
+            nextPinnedByAgent[agentId] = pinnedThreadIds;
+        }
+        else {
+            delete nextPinnedByAgent[agentId];
+        }
+        if (Object.keys(nextPinnedByAgent).length > 0) {
+            next.pinnedThreadIdsByAgent = nextPinnedByAgent;
         }
         this.metadata.set(contextKey, next);
         this.persistMetadata();
     }
     pinThread(contextKey, threadId) {
         const meta = this.metadata.get(contextKey) ?? this.createEmptyMetadata(contextKey);
-        const pinned = new Set(meta.pinnedThreadIds ?? []);
+        const agentId = meta.agentId ?? this.config.defaultAgent ?? "codex";
+        const pinnedByAgent = meta.pinnedThreadIdsByAgent ?? {};
+        const pinned = new Set(pinnedByAgent[agentId] ?? meta.pinnedThreadIds ?? []);
         pinned.add(threadId);
-        meta.pinnedThreadIds = [...pinned];
+        meta.pinnedThreadIdsByAgent = { ...pinnedByAgent, [agentId]: [...pinned] };
+        delete meta.pinnedThreadIds;
         meta.updatedAt = Date.now();
         this.metadata.set(contextKey, meta);
         this.persistMetadata();
-        return meta.pinnedThreadIds;
+        return meta.pinnedThreadIdsByAgent[agentId] ?? [];
     }
     unpinThread(contextKey, threadId) {
         const meta = this.metadata.get(contextKey) ?? this.createEmptyMetadata(contextKey);
-        meta.pinnedThreadIds = (meta.pinnedThreadIds ?? []).filter((id) => id !== threadId);
+        const agentId = meta.agentId ?? this.config.defaultAgent ?? "codex";
+        const pinnedByAgent = meta.pinnedThreadIdsByAgent ?? {};
+        meta.pinnedThreadIdsByAgent = {
+            ...pinnedByAgent,
+            [agentId]: (pinnedByAgent[agentId] ?? meta.pinnedThreadIds ?? []).filter((id) => id !== threadId),
+        };
+        delete meta.pinnedThreadIds;
         meta.updatedAt = Date.now();
         this.metadata.set(contextKey, meta);
         this.persistMetadata();
-        return meta.pinnedThreadIds;
+        return meta.pinnedThreadIdsByAgent[agentId] ?? [];
     }
     listPinnedThreadIds(contextKey) {
-        return [...(this.metadata.get(contextKey)?.pinnedThreadIds ?? [])];
+        const meta = this.metadata.get(contextKey);
+        const agentId = meta?.agentId ?? this.config.defaultAgent ?? "codex";
+        return [...(meta?.pinnedThreadIdsByAgent?.[agentId] ?? meta?.pinnedThreadIds ?? [])];
     }
     listContexts() {
         return [...this.metadata.values()].sort((left, right) => right.updatedAt - left.updatedAt);
     }
-    syncAllFromCodexState(options = {}) {
+    syncAllFromAgentState(options = {}) {
         const results = [];
         for (const [contextKey, session] of this.sessions.entries()) {
             if (!(session.getInfo().capabilities ?? CODEX_AGENT_CAPABILITIES).externalActivity) {
                 continue;
             }
-            const result = session.syncFromCodexState(options);
+            const result = session.syncFromAgentState(options);
             if (result.changed) {
                 this.updateMetadata(contextKey, session);
             }
@@ -168,7 +186,10 @@ export class SessionRegistry {
             }
             for (const entry of data) {
                 if (entry.contextKey) {
-                    this.metadata.set(entry.contextKey, entry);
+                    this.metadata.set(entry.contextKey, {
+                        ...entry,
+                        agentId: entry.agentId ?? "codex",
+                    });
                 }
             }
         }
@@ -179,6 +200,7 @@ export class SessionRegistry {
     createEmptyMetadata(contextKey) {
         return {
             contextKey,
+            agentId: this.config.defaultAgent ?? "codex",
             threadId: null,
             workspace: this.config.workspace,
             launchProfileId: this.config.defaultLaunchProfileId,
@@ -191,6 +213,9 @@ function resolveLaunchProfileId(config, meta) {
     if (!meta?.launchProfileId) {
         return undefined;
     }
+    if (meta.agentId === "pi" || meta.agentId === "hermes" || meta.agentId === "openclaw" || meta.agentId === "claude-code") {
+        return meta.launchProfileId;
+    }
     if (findLaunchProfile(config.launchProfiles, meta.launchProfileId)) {
         return meta.launchProfileId;
     }

package/dist/settings-service.js

@@ -3,6 +3,9 @@ import path from "node:path";
 const SECRET_KEYS = new Set([
     "TELEGRAM_BOT_TOKEN",
     "CODEX_API_KEY",
+    "HERMES_API_KEY",
+    "OPENCLAW_GATEWAY_TOKEN",
+    "OPENCLAW_GATEWAY_PASSWORD",
     "OPENAI_API_KEY",
     "TELEGRAM_WEBHOOK_SECRET",
     "NORDRELAY_DASHBOARD_TOKEN",
@@ -24,7 +27,10 @@ export const SETTING_DEFINITIONS = [
     setting("TELEGRAM_WEBHOOK_SECRET", "Webhook secret", "Telegram", "secret", "Optional Telegram webhook secret token.", true),
     setting("NORDRELAY_CODEX_ENABLED", "Enable Codex", "Agents", "boolean", "Allow Codex sessions.", true),
     setting("NORDRELAY_PI_ENABLED", "Enable Pi", "Agents", "boolean", "Allow Pi sessions.", true),
-    setting("NORDRELAY_DEFAULT_AGENT", "Default agent", "Agents", "string", "codex or pi.", true, ["codex", "pi"]),
+    setting("NORDRELAY_HERMES_ENABLED", "Enable Hermes", "Agents", "boolean", "Allow Hermes sessions through the Hermes API Server.", true),
+    setting("NORDRELAY_OPENCLAW_ENABLED", "Enable OpenClaw", "Agents", "boolean", "Allow OpenClaw sessions through the OpenClaw Gateway.", true),
+    setting("NORDRELAY_CLAUDE_CODE_ENABLED", "Enable Claude Code", "Agents", "boolean", "Allow Claude Code sessions through the Claude Agent SDK.", true),
+    setting("NORDRELAY_DEFAULT_AGENT", "Default agent", "Agents", "string", "codex, pi, hermes, openclaw, or claude-code.", true, ["codex", "pi", "hermes", "openclaw", "claude-code"]),
     setting("CODEX_API_KEY", "Codex API key", "Codex", "secret", "Optional Codex SDK API key.", true),
     setting("CODEX_CLI_PATH", "Codex CLI path", "Codex", "string", "Optional explicit Codex executable path.", true),
     setting("CODEX_USE_BUNDLED_CLI", "Use bundled Codex CLI", "Codex", "boolean", "Force SDK-bundled CLI instead of host CLI.", true),
@@ -41,6 +47,31 @@ export const SETTING_DEFINITIONS = [
     setting("PI_SESSION_DIR", "Pi session dir", "Pi", "string", "Optional Pi session directory.", true),
     setting("PI_DEFAULT_MODEL", "Default Pi model", "Pi", "string", "Default Pi model slug.", false),
     setting("PI_DEFAULT_THINKING", "Default Pi thinking", "Pi", "string", "off, minimal, low, medium, high, or xhigh.", false, ["off", "minimal", "low", "medium", "high", "xhigh"]),
+    setting("PI_DEFAULT_PROFILE", "Default Pi profile", "Pi", "string", "default, readonly, no-tools, offline, or safe-offline.", true, ["default", "readonly", "no-tools", "offline", "safe-offline"]),
+    setting("HERMES_CLI_PATH", "Hermes CLI path", "Hermes", "string", "Optional Hermes executable path.", true),
+    setting("HERMES_HOME", "Hermes home", "Hermes", "string", "Optional Hermes home directory. Defaults to ~/.hermes.", true),
+    setting("HERMES_STATE_DB_PATH", "Hermes state DB path", "Hermes", "string", "Optional explicit Hermes state.db path.", true),
+    setting("HERMES_API_BASE_URL", "Hermes API base URL", "Hermes", "string", "Hermes API Server base URL.", true),
+    setting("HERMES_API_KEY", "Hermes API key", "Hermes", "secret", "Bearer token for the Hermes API Server.", true),
+    setting("HERMES_DEFAULT_MODEL", "Default Hermes model", "Hermes", "string", "Default model label sent to Hermes API runs.", false),
+    setting("HERMES_DEFAULT_REASONING", "Default Hermes reasoning", "Hermes", "string", "none, minimal, low, medium, high, or xhigh.", false, ["none", "minimal", "low", "medium", "high", "xhigh"]),
+    setting("HERMES_DEFAULT_PROFILE", "Default Hermes profile", "Hermes", "string", "default, safe, readonly, or yolo.", true, ["default", "safe", "readonly", "yolo"]),
+    setting("OPENCLAW_CLI_PATH", "OpenClaw CLI path", "OpenClaw", "string", "Optional OpenClaw executable path.", true),
+    setting("OPENCLAW_GATEWAY_URL", "OpenClaw Gateway URL", "OpenClaw", "string", "OpenClaw Gateway WebSocket URL.", true),
+    setting("OPENCLAW_GATEWAY_TOKEN", "OpenClaw Gateway token", "OpenClaw", "secret", "Shared-secret token for the OpenClaw Gateway.", true),
+    setting("OPENCLAW_GATEWAY_PASSWORD", "OpenClaw Gateway password", "OpenClaw", "secret", "Shared-secret password for the OpenClaw Gateway.", true),
+    setting("OPENCLAW_AGENT_ID", "OpenClaw agent ID", "OpenClaw", "string", "Configured OpenClaw agent id, for example main or work.", false),
+    setting("OPENCLAW_HOME", "OpenClaw home", "OpenClaw", "string", "Optional OpenClaw home directory. Defaults to ~/.openclaw.", true),
+    setting("OPENCLAW_STATE_DIR", "OpenClaw state dir", "OpenClaw", "string", "Optional OpenClaw state directory.", true),
+    setting("OPENCLAW_DEFAULT_MODEL", "Default OpenClaw model", "OpenClaw", "string", "Default OpenClaw model id.", false),
+    setting("OPENCLAW_DEFAULT_THINKING", "Default OpenClaw thinking", "OpenClaw", "string", "off, minimal, low, medium, high, or xhigh.", false, ["off", "minimal", "low", "medium", "high", "xhigh"]),
+    setting("OPENCLAW_DEFAULT_PROFILE", "Default OpenClaw profile", "OpenClaw", "string", "default, safe, readonly, local, or deliver.", true, ["default", "safe", "readonly", "local", "deliver"]),
+    setting("CLAUDE_CODE_CLI_PATH", "Claude Code CLI path", "Claude Code", "string", "Optional Claude Code executable path. Defaults to claude on PATH or the SDK bundled runtime.", true),
+    setting("CLAUDE_CONFIG_DIR", "Claude config dir", "Claude Code", "string", "Optional Claude config directory. Defaults to ~/.claude.", true),
+    setting("CLAUDE_CODE_DEFAULT_MODEL", "Default Claude Code model", "Claude Code", "string", "Default Claude Code model alias or model id.", false),
+    setting("CLAUDE_CODE_DEFAULT_EFFORT", "Default Claude Code effort", "Claude Code", "string", "off, low, medium, high, or xhigh.", false, ["off", "low", "medium", "high", "xhigh"]),
+    setting("CLAUDE_CODE_DEFAULT_PROFILE", "Default Claude Code profile", "Claude Code", "string", "default, accept-edits, plan, readonly, no-tools, or bypass-permissions.", true, ["default", "accept-edits", "plan", "readonly", "no-tools", "bypass-permissions"]),
+    setting("CLAUDE_CODE_MAX_TURNS", "Claude Code max turns", "Claude Code", "number", "Maximum agentic turns for each Claude Code prompt.", false),
     setting("CONNECTOR_LOG_FORMAT", "Log format", "Operations", "string", "text or json.", true, ["text", "json"]),
     setting("TOOL_VERBOSITY", "Tool verbosity", "Operations", "string", "all, summary, errors-only, or none.", false, ["all", "summary", "errors-only", "none"]),
     setting("SHOW_TURN_TOKEN_USAGE", "Show turn token usage", "Operations", "boolean", "Append per-turn token usage.", false),
@@ -88,15 +119,15 @@ export class SettingsService {
     constructor(envPath) {
         this.envPath = envPath;
     }
-    async snapshot(env = process.env) {
+    async snapshot(env = process.env, activeValues = {}) {
         const parsed = await readEnvFile(this.envPath);
         const settings = SETTING_DEFINITIONS.map((definition) => {
             const configuredValue = parsed[definition.key];
-            const effectiveValue = configuredValue ?? env[definition.key] ?? "";
+            const effectiveValue = configuredValue ?? activeValues[definition.key] ?? env[definition.key] ?? "";
             const masked = SECRET_KEYS.has(definition.key) && Boolean(effectiveValue);
             return {
                 ...definition,
-                value: masked ? maskSecret(effectiveValue) : effectiveValue,
+                value: configuredValue === undefined ? "" : SECRET_KEYS.has(definition.key) && configuredValue ? maskSecret(configuredValue) : configuredValue,
                 effectiveValue: masked ? maskSecret(effectiveValue) : effectiveValue,
                 configured: configuredValue !== undefined,
                 masked,

package/dist/web-dashboard-assets.js

@@ -0,0 +1,2 @@
+export { dashboardJs } from "./web-dashboard-client.js";
+export { dashboardCss } from "./web-dashboard-style.js";