@nordbyte/nordrelay 0.3.1 → 0.4.1

package/dist/agent-activity.js

@@ -0,0 +1,300 @@
+import { CODEX_AGENT_CAPABILITIES, } from "./agent.js";
+import { getThreadActivity, getThreadActivityLog, getThreadRolloutSnapshot, } from "./codex-state.js";
+import { getClaudeCodeSessionActivity, getClaudeCodeSessionActivityLog, getClaudeCodeSessionDiagnostics, getClaudeCodeSessionSnapshot, } from "./claude-code-state.js";
+import { getHermesSessionActivity, getHermesSessionActivityLog, getHermesSessionDiagnostics, getHermesSessionSnapshot, } from "./hermes-state.js";
+import { getOpenClawSessionActivity, getOpenClawSessionActivityLog, getOpenClawSessionDiagnostics, getOpenClawSessionSnapshot, } from "./openclaw-state.js";
+import { getPiSessionActivity, getPiSessionActivityLog, getPiSessionDiagnostics, getPiSessionSnapshot, } from "./pi-state.js";
+export function getExternalActivityForSession(session, config) {
+    const info = session?.getInfo();
+    if (!info || !(info.capabilities ?? CODEX_AGENT_CAPABILITIES).externalActivity) {
+        return null;
+    }
+    const threadId = session?.getActiveThreadId();
+    if (!threadId) {
+        return null;
+    }
+    if (info.agentId === "pi") {
+        return getPiSessionActivity(info.sessionPath ?? threadId, {
+            sessionDir: config.piSessionDir,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+    }
+    if (info.agentId === "hermes") {
+        return getHermesSessionActivity(threadId, {
+            hermesHome: config.hermesHome,
+            stateDbPath: config.hermesStateDbPath,
+            workspace: info.workspace,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+    }
+    if (info.agentId === "openclaw") {
+        return getOpenClawSessionActivity(threadId, {
+            cliPath: config.openClawCliPath,
+            openClawHome: config.openClawHome,
+            stateDir: config.openClawStateDir,
+            workspace: info.workspace,
+            openClawAgentId: config.openClawAgentId,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+    }
+    if (info.agentId === "claude-code") {
+        return getClaudeCodeSessionActivity(threadId, {
+            configDir: config.claudeCodeConfigDir,
+            workspace: info.workspace,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+    }
+    const activity = getThreadActivity(threadId, {
+        staleAfterMs: config.codexExternalBusyStaleMs,
+    });
+    if (!activity) {
+        return null;
+    }
+    return {
+        agentId: "codex",
+        agentLabel: "Codex",
+        threadId: activity.threadId,
+        sourcePath: activity.rolloutPath,
+        sourceLabel: "Codex rollout",
+        active: activity.active,
+        stale: activity.stale,
+        turnId: activity.turnId,
+        startedAt: activity.startedAt,
+        updatedAt: activity.updatedAt,
+    };
+}
+export function getExternalSnapshotForSession(session, config, options = {}) {
+    const info = session.getInfo();
+    const threadId = session.getActiveThreadId();
+    if (!(info.capabilities ?? CODEX_AGENT_CAPABILITIES).externalActivity || !threadId) {
+        return null;
+    }
+    if (info.agentId === "pi") {
+        return getPiSessionSnapshot(info.sessionPath ?? threadId, {
+            sessionDir: config.piSessionDir,
+            afterLine: options.afterLine,
+            maxEvents: options.maxEvents,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+    }
+    if (info.agentId === "hermes") {
+        return getHermesSessionSnapshot(threadId, {
+            hermesHome: config.hermesHome,
+            stateDbPath: config.hermesStateDbPath,
+            workspace: info.workspace,
+            afterLine: options.afterLine,
+            maxEvents: options.maxEvents,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+    }
+    if (info.agentId === "openclaw") {
+        return getOpenClawSessionSnapshot(threadId, {
+            cliPath: config.openClawCliPath,
+            openClawHome: config.openClawHome,
+            stateDir: config.openClawStateDir,
+            workspace: info.workspace,
+            openClawAgentId: config.openClawAgentId,
+            afterLine: options.afterLine,
+            maxEvents: options.maxEvents,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+    }
+    if (info.agentId === "claude-code") {
+        return getClaudeCodeSessionSnapshot(threadId, {
+            configDir: config.claudeCodeConfigDir,
+            workspace: info.workspace,
+            afterLine: options.afterLine,
+            maxEvents: options.maxEvents,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+    }
+    const snapshot = getThreadRolloutSnapshot(threadId, {
+        afterLine: options.afterLine,
+        maxEvents: options.maxEvents,
+        staleAfterMs: config.codexExternalBusyStaleMs,
+    });
+    return snapshot ? codexSnapshotToAgentSnapshot(snapshot) : null;
+}
+export function getAgentActivityLog(session, config, limit) {
+    const info = session.getInfo();
+    const threadId = session.getActiveThreadId();
+    if (!threadId) {
+        return [];
+    }
+    if (info.agentId === "pi") {
+        return getPiSessionActivityLog(info.sessionPath ?? threadId, limit, { sessionDir: config.piSessionDir });
+    }
+    if (info.agentId === "hermes") {
+        return getHermesSessionActivityLog(threadId, limit, {
+            hermesHome: config.hermesHome,
+            stateDbPath: config.hermesStateDbPath,
+            workspace: info.workspace,
+        });
+    }
+    if (info.agentId === "openclaw") {
+        return getOpenClawSessionActivityLog(threadId, limit, {
+            cliPath: config.openClawCliPath,
+            openClawHome: config.openClawHome,
+            stateDir: config.openClawStateDir,
+            workspace: info.workspace,
+            openClawAgentId: config.openClawAgentId,
+        });
+    }
+    if (info.agentId === "claude-code") {
+        return getClaudeCodeSessionActivityLog(threadId, limit, {
+            configDir: config.claudeCodeConfigDir,
+            workspace: info.workspace,
+        });
+    }
+    return getThreadActivityLog(threadId, limit).map(codexEventToAgentEvent);
+}
+export function getAgentDiagnostics(session, config) {
+    const info = session.getInfo();
+    if (info.agentId === "pi") {
+        const diagnostics = getPiSessionDiagnostics(info.sessionPath ?? info.threadId, {
+            sessionDir: config.piSessionDir,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+        return {
+            agentId: "pi",
+            agentLabel: "Pi",
+            lines: [
+                { label: "Pi session dir", value: diagnostics.sessionDir },
+                { label: "Pi session file", value: diagnostics.sessionPath ?? "-" },
+                { label: "Pi session status", value: diagnostics.status },
+                { label: "Pi status reason", value: diagnostics.reason },
+                { label: "Pi JSONL lines", value: String(diagnostics.lineCount) },
+                { label: "Pi updated", value: diagnostics.updatedAt?.toISOString() ?? "-" },
+                { label: "Pi RPC active", value: session.isProcessing() ? "yes" : "idle" },
+            ],
+        };
+    }
+    if (info.agentId === "hermes") {
+        const diagnostics = getHermesSessionDiagnostics(info.threadId, {
+            hermesHome: config.hermesHome,
+            stateDbPath: config.hermesStateDbPath,
+            workspace: info.workspace,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+        return {
+            agentId: "hermes",
+            agentLabel: "Hermes",
+            lines: [
+                { label: "Hermes API", value: config.hermesApiBaseUrl },
+                { label: "Hermes state DB", value: diagnostics.stateDbPath },
+                { label: "Hermes session status", value: diagnostics.status },
+                { label: "Hermes status reason", value: diagnostics.reason },
+                { label: "Hermes messages", value: String(diagnostics.lineCount) },
+                { label: "Hermes updated", value: diagnostics.updatedAt?.toISOString() ?? "-" },
+                { label: "Hermes API run active", value: session.isProcessing() ? "yes" : "idle" },
+            ],
+        };
+    }
+    if (info.agentId === "openclaw") {
+        const diagnostics = getOpenClawSessionDiagnostics(info.threadId, {
+            cliPath: config.openClawCliPath,
+            openClawHome: config.openClawHome,
+            stateDir: config.openClawStateDir,
+            workspace: info.workspace,
+            openClawAgentId: config.openClawAgentId,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+        return {
+            agentId: "openclaw",
+            agentLabel: "OpenClaw",
+            lines: [
+                { label: "OpenClaw Gateway", value: config.openClawGatewayUrl },
+                { label: "OpenClaw sessions", value: diagnostics.sourcePath },
+                { label: "OpenClaw session status", value: diagnostics.status },
+                { label: "OpenClaw status reason", value: diagnostics.reason },
+                { label: "OpenClaw events", value: String(diagnostics.lineCount) },
+                { label: "OpenClaw updated", value: diagnostics.updatedAt?.toISOString() ?? "-" },
+                { label: "OpenClaw Gateway run active", value: session.isProcessing() ? "yes" : "idle" },
+            ],
+        };
+    }
+    if (info.agentId === "claude-code") {
+        const diagnostics = getClaudeCodeSessionDiagnostics(info.threadId, {
+            configDir: config.claudeCodeConfigDir,
+            workspace: info.workspace,
+            staleAfterMs: config.codexExternalBusyStaleMs,
+        });
+        return {
+            agentId: "claude-code",
+            agentLabel: "Claude Code",
+            lines: [
+                { label: "Claude projects dir", value: diagnostics.projectsDir },
+                { label: "Claude session file", value: diagnostics.sessionPath ?? "-" },
+                { label: "Claude session status", value: diagnostics.status },
+                { label: "Claude status reason", value: diagnostics.reason },
+                { label: "Claude JSONL lines", value: String(diagnostics.lineCount) },
+                { label: "Claude updated", value: diagnostics.updatedAt?.toISOString() ?? "-" },
+                { label: "Claude SDK run active", value: session.isProcessing() ? "yes" : "idle" },
+            ],
+        };
+    }
+    const snapshot = info.threadId
+        ? getThreadRolloutSnapshot(info.threadId, { staleAfterMs: config.codexExternalBusyStaleMs, maxEvents: 0 })
+        : null;
+    const status = !info.threadId ? "unavailable" : snapshot?.activity.active ? "active" : snapshot?.activity.stale ? "stale" : snapshot ? "idle" : "unavailable";
+    const reason = !info.threadId
+        ? "no active thread"
+        : snapshot?.activity.active
+            ? "open task without terminal event"
+            : snapshot?.activity.stale
+                ? "open task exceeded stale timeout"
+                : snapshot
+                    ? "no open task"
+                    : "rollout unavailable";
+    return {
+        agentId: "codex",
+        agentLabel: "Codex",
+        lines: [
+            { label: "Rollout path", value: snapshot?.rolloutPath ?? "-" },
+            { label: "Rollout status", value: status },
+            { label: "Rollout reason", value: reason },
+            { label: "Rollout turn", value: snapshot?.activity.turnId ?? "-" },
+            { label: "Rollout lines", value: String(snapshot?.lineCount ?? 0) },
+            { label: "Rollout updated", value: snapshot?.activity.updatedAt?.toISOString() ?? "-" },
+        ],
+    };
+}
+function codexSnapshotToAgentSnapshot(snapshot) {
+    return {
+        agentId: "codex",
+        agentLabel: "Codex",
+        threadId: snapshot.threadId,
+        sourcePath: snapshot.rolloutPath,
+        sourceLabel: "Codex rollout",
+        lineCount: snapshot.lineCount,
+        activity: {
+            agentId: "codex",
+            agentLabel: "Codex",
+            threadId: snapshot.threadId,
+            sourcePath: snapshot.rolloutPath,
+            sourceLabel: "Codex rollout",
+            active: snapshot.activity.active,
+            stale: snapshot.activity.stale,
+            turnId: snapshot.activity.turnId,
+            startedAt: snapshot.activity.startedAt,
+            updatedAt: snapshot.activity.updatedAt,
+        },
+        events: snapshot.events.map(codexEventToAgentEvent),
+        latestAgentMessage: snapshot.latestAgentMessage,
+        latestUserMessage: snapshot.latestUserMessage,
+        latestToolName: snapshot.latestToolName,
+    };
+}
+function codexEventToAgentEvent(event) {
+    return {
+        lineNumber: event.lineNumber,
+        kind: event.kind,
+        timestamp: event.timestamp,
+        type: event.type,
+        turnId: event.turnId,
+        status: event.status,
+        text: event.text,
+        toolName: event.toolName,
+        phase: event.phase,
+    };
+}

package/dist/agent-adapter.js

@@ -1,4 +1,4 @@
-import { CODEX_AGENT_CAPABILITIES, PI_AGENT_CAPABILITIES, } from "./agent.js";
+import { CLAUDE_CODE_AGENT_CAPABILITIES, CODEX_AGENT_CAPABILITIES, HERMES_AGENT_CAPABILITIES, OPENCLAW_AGENT_CAPABILITIES, PI_AGENT_CAPABILITIES, } from "./agent.js";
 export const BUILTIN_AGENT_ADAPTERS = [
     {
         id: "codex",
@@ -15,23 +15,28 @@ export const BUILTIN_AGENT_ADAPTERS = [
         envFlag: "NORDRELAY_PI_ENABLED",
     },
     {
-        id: "claude-code",
-        label: "Claude Code",
-        status: "planned",
-        capabilities: plannedCapabilities(),
-        notes: "Use this descriptor as the target contract for a future Claude Code session service.",
+        id: "hermes",
+        label: "Hermes",
+        status: "available",
+        capabilities: HERMES_AGENT_CAPABILITIES,
+        envFlag: "NORDRELAY_HERMES_ENABLED",
+        notes: "Uses the Hermes API Server for streaming runs, stop, session continuity, and tool lifecycle events.",
     },
     {
         id: "openclaw",
         label: "OpenClaw",
-        status: "planned",
-        capabilities: plannedCapabilities(),
+        status: "available",
+        capabilities: OPENCLAW_AGENT_CAPABILITIES,
+        envFlag: "NORDRELAY_OPENCLAW_ENABLED",
+        notes: "Uses the OpenClaw Gateway WebSocket RPC surface for streamed agent runs, session continuity, and tool lifecycle events.",
     },
     {
-        id: "hermes",
-        label: "Hermes",
-        status: "planned",
-        capabilities: plannedCapabilities(),
+        id: "claude-code",
+        label: "Claude Code",
+        status: "available",
+        capabilities: CLAUDE_CODE_AGENT_CAPABILITIES,
+        envFlag: "NORDRELAY_CLAUDE_CODE_ENABLED",
+        notes: "Uses the Claude Agent SDK with host Claude Code sessions, streaming, tool lifecycle events, session continuity, and handback.",
     },
 ];
 export function listAgentAdapterDescriptors() {
@@ -40,21 +45,3 @@ export function listAgentAdapterDescriptors() {
         capabilities: { ...descriptor.capabilities },
     }));
 }
-function plannedCapabilities() {
-    return {
-        launchProfiles: false,
-        fastMode: false,
-        externalActivity: false,
-        cliMirror: false,
-        activityLog: false,
-        auth: false,
-        login: false,
-        logout: false,
-        usageLimits: false,
-        workspaces: true,
-        attachments: true,
-        modelSelection: true,
-        reasoningSelection: true,
-        handback: true,
-    };
-}

package/dist/agent-factory.js

@@ -1,4 +1,7 @@
 import { CodexSessionService } from "./codex-session.js";
+import { ClaudeCodeSessionService } from "./claude-code-session.js";
+import { HermesSessionService } from "./hermes-session.js";
+import { OpenClawSessionService } from "./openclaw-session.js";
 import { PiSessionService } from "./pi-session.js";
 export async function createAgentSessionService(config, agentId, options) {
     if (agentId === "pi") {
@@ -7,6 +10,24 @@ export async function createAgentSessionService(config, agentId, options) {
         }
         return PiSessionService.create(config, options);
     }
+    if (agentId === "hermes") {
+        if (config.hermesEnabled !== true) {
+            throw new Error("Hermes support is disabled. Set NORDRELAY_HERMES_ENABLED=true.");
+        }
+        return HermesSessionService.create(config, options);
+    }
+    if (agentId === "openclaw") {
+        if (config.openClawEnabled !== true) {
+            throw new Error("OpenClaw support is disabled. Set NORDRELAY_OPENCLAW_ENABLED=true.");
+        }
+        return OpenClawSessionService.create(config, options);
+    }
+    if (agentId === "claude-code") {
+        if (config.claudeCodeEnabled !== true) {
+            throw new Error("Claude Code support is disabled. Set NORDRELAY_CLAUDE_CODE_ENABLED=true.");
+        }
+        return ClaudeCodeSessionService.create(config, options);
+    }
     if (config.codexEnabled === false) {
         throw new Error("Codex support is disabled. Set NORDRELAY_CODEX_ENABLED=true.");
     }
@@ -18,5 +39,11 @@ export function enabledAgents(config) {
         agents.push("codex");
     if (config.piEnabled)
         agents.push("pi");
+    if (config.hermesEnabled)
+        agents.push("hermes");
+    if (config.openClawEnabled)
+        agents.push("openclaw");
+    if (config.claudeCodeEnabled)
+        agents.push("claude-code");
     return agents;
 }

package/dist/agent-feature-matrix.js

@@ -0,0 +1,42 @@
+import { escapeHTML } from "./format.js";
+export const AGENT_FEATURES = [
+    { key: "modelSelection", label: "Model", description: "Pick the model used for new turns or sessions." },
+    { key: "reasoningSelection", label: "Reasoning", description: "Pick thinking/reasoning effort where the agent exposes it." },
+    { key: "launchProfiles", label: "Launch profiles", description: "Switch sandbox/approval launch behavior for new sessions." },
+    { key: "fastMode", label: "Fast mode", description: "Toggle the agent-specific low-latency mode." },
+    { key: "workspaces", label: "Workspaces", description: "List and switch allowed workspaces." },
+    { key: "attachments", label: "Files/images", description: "Send files, photos, staged attachments, and voice transcripts." },
+    { key: "externalActivity", label: "External busy", description: "Detect active CLI turns started outside NordRelay." },
+    { key: "cliMirror", label: "CLI mirror", description: "Mirror CLI-started turns back to Telegram/WebUI." },
+    { key: "activityLog", label: "Activity", description: "Read activity timelines for sessions and turns." },
+    { key: "usageStats", label: "Usage stats", description: "Show token/context usage reported by the agent." },
+    { key: "subscriptionLimits", label: "Limits", description: "Show subscription/quota limits when the agent exposes them." },
+    { key: "auth", label: "Auth status", description: "Check whether the agent is authenticated." },
+    { key: "login", label: "Login", description: "Start an agent login flow from NordRelay." },
+    { key: "logout", label: "Logout", description: "Sign out of the agent from NordRelay." },
+    { key: "handback", label: "Handback", description: "Return a remote session to the native CLI." },
+];
+export function agentFeatureStates(capabilities) {
+    return AGENT_FEATURES.map((feature) => ({
+        ...feature,
+        supported: Boolean(capabilities[feature.key]),
+    }));
+}
+export function formatAgentFeatureSummaryPlain(capabilities) {
+    const states = agentFeatureStates(capabilities);
+    const supported = states.filter((feature) => feature.supported).map((feature) => feature.label);
+    const unsupported = states.filter((feature) => !feature.supported).map((feature) => feature.label);
+    return [
+        `Supported: ${supported.join(", ") || "-"}`,
+        `Not supported: ${unsupported.join(", ") || "-"}`,
+    ];
+}
+export function formatAgentFeatureSummaryHTML(capabilities) {
+    const states = agentFeatureStates(capabilities);
+    const supported = states.filter((feature) => feature.supported).map((feature) => feature.label);
+    const unsupported = states.filter((feature) => !feature.supported).map((feature) => feature.label);
+    return [
+        `<b>Supported:</b> ${escapeHTML(supported.join(", ") || "-")}`,
+        `<b>Not supported:</b> ${escapeHTML(unsupported.join(", ") || "-")}`,
+    ];
+}