@nordbyte/nordrelay 0.3.1 → 0.4.0

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.js

@@ -1,4 +1,4 @@
-export const AGENT_IDS = ["codex", "pi"];
+export const AGENT_IDS = ["codex", "pi", "hermes", "openclaw", "claude-code"];
 export const CODEX_REASONING_EFFORTS = [
     "minimal",
     "low",
@@ -14,6 +14,29 @@ export const PI_THINKING_LEVELS = [
     "high",
     "xhigh",
 ];
+export const HERMES_REASONING_EFFORTS = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+];
+export const OPENCLAW_THINKING_LEVELS = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+];
+export const CLAUDE_CODE_EFFORT_LEVELS = [
+    "off",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+];
 export const CODEX_AGENT_CAPABILITIES = {
     launchProfiles: true,
     fastMode: true,
@@ -23,6 +46,8 @@ export const CODEX_AGENT_CAPABILITIES = {
     auth: true,
     login: true,
     logout: true,
+    usageStats: true,
+    subscriptionLimits: true,
     usageLimits: true,
     workspaces: true,
     attachments: true,
@@ -31,14 +56,70 @@ export const CODEX_AGENT_CAPABILITIES = {
     handback: true,
 };
 export const PI_AGENT_CAPABILITIES = {
-    launchProfiles: false,
+    launchProfiles: true,
+    fastMode: false,
+    externalActivity: true,
+    cliMirror: true,
+    activityLog: true,
+    auth: true,
+    login: false,
+    logout: false,
+    usageStats: true,
+    subscriptionLimits: false,
+    usageLimits: false,
+    workspaces: true,
+    attachments: true,
+    modelSelection: true,
+    reasoningSelection: true,
+    handback: true,
+};
+export const HERMES_AGENT_CAPABILITIES = {
+    launchProfiles: true,
     fastMode: false,
-    externalActivity: false,
-    cliMirror: false,
-    activityLog: false,
-    auth: false,
+    externalActivity: true,
+    cliMirror: true,
+    activityLog: true,
+    auth: true,
+    login: true,
+    logout: true,
+    usageStats: true,
+    subscriptionLimits: false,
+    usageLimits: false,
+    workspaces: true,
+    attachments: true,
+    modelSelection: true,
+    reasoningSelection: true,
+    handback: true,
+};
+export const OPENCLAW_AGENT_CAPABILITIES = {
+    launchProfiles: true,
+    fastMode: false,
+    externalActivity: true,
+    cliMirror: true,
+    activityLog: true,
+    auth: true,
     login: false,
     logout: false,
+    usageStats: true,
+    subscriptionLimits: false,
+    usageLimits: false,
+    workspaces: true,
+    attachments: true,
+    modelSelection: true,
+    reasoningSelection: true,
+    handback: true,
+};
+export const CLAUDE_CODE_AGENT_CAPABILITIES = {
+    launchProfiles: true,
+    fastMode: false,
+    externalActivity: true,
+    cliMirror: true,
+    activityLog: true,
+    auth: true,
+    login: true,
+    logout: true,
+    usageStats: true,
+    subscriptionLimits: false,
     usageLimits: false,
     workspaces: true,
     attachments: true,
@@ -47,11 +128,44 @@ export const PI_AGENT_CAPABILITIES = {
     handback: true,
 };
 export function isAgentId(value) {
-    return value === "codex" || value === "pi";
+    return AGENT_IDS.includes(value);
 }
 export function agentLabel(agentId) {
-    return agentId === "pi" ? "Pi" : "Codex";
+    if (agentId === "pi") {
+        return "Pi";
+    }
+    if (agentId === "hermes") {
+        return "Hermes";
+    }
+    if (agentId === "openclaw") {
+        return "OpenClaw";
+    }
+    if (agentId === "claude-code") {
+        return "Claude Code";
+    }
+    return "Codex";
 }
 export function agentReasoningLabel(agentId) {
-    return agentId === "pi" ? "Thinking" : "Reasoning";
+    if (agentId === "pi" || agentId === "openclaw") {
+        return "Thinking";
+    }
+    if (agentId === "claude-code") {
+        return "Effort";
+    }
+    return "Reasoning";
+}
+export function agentReasoningOptions(agentId) {
+    if (agentId === "pi") {
+        return PI_THINKING_LEVELS;
+    }
+    if (agentId === "hermes") {
+        return HERMES_REASONING_EFFORTS;
+    }
+    if (agentId === "openclaw") {
+        return OPENCLAW_THINKING_LEVELS;
+    }
+    if (agentId === "claude-code") {
+        return CLAUDE_CODE_EFFORT_LEVELS;
+    }
+    return CODEX_REASONING_EFFORTS;
 }

package/dist/artifacts.js

@@ -178,7 +178,7 @@ export async function createArtifactZipBundle(artifacts, outDir, options = {}) {
     }
     const bundleDir = path.join(outDir, ".telegram-artifacts");
     await mkdir(bundleDir, { recursive: true });
-    const bundleName = options.bundleName ?? `codex-artifacts-${sanitizeZipStem(path.basename(path.dirname(outDir)))}.zip`;
+    const bundleName = options.bundleName ?? `nordrelay-artifacts-${sanitizeZipStem(path.basename(path.dirname(outDir)))}.zip`;
     const bundlePath = path.join(bundleDir, bundleName);
     await rm(bundlePath, { force: true }).catch(() => { });
     try {

package/dist/audit-log.js

@@ -17,8 +17,8 @@ export class AuditLogStore {
         const next = {
             id: randomUUID().replace(/-/g, "").slice(0, 12),
             timestamp: new Date().toISOString(),
-            channelId: "telegram",
             ...event,
+            channelId: event.channelId ?? "telegram",
         };
         payload.events.push(next);
         if (payload.events.length > this.maxEvents) {

package/dist/bot-ui.js

@@ -8,7 +8,7 @@ export function renderHelpMessage() {
             title: "💬 Session",
             commands: [
                 ["/new", "Start a new thread"],
-                ["/agent", "Select Codex or Pi"],
+                ["/agent", "Select agent"],
                 ["/session", "Current thread details"],
                 ["/sessions", "Browse & switch threads"],
                 ["/sync", "Sync active sessions from CLI state"],