@nordbyte/nordrelay 0.8.1 → 0.8.2

package/dist/runtime/relay-runtime-active-sessions.js

@@ -0,0 +1,387 @@
+import { randomUUID } from "node:crypto";
+import { ensureOutDir } from "../artifacts/artifacts.js";
+import { buildFileInstructions, outboxPath, stageFile, } from "../artifacts/attachments.js";
+import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, isAgentId, } from "../agents/shared/agent.js";
+import { getExternalSnapshotForSession } from "../agents/shared/agent-activity.js";
+import { listAgentAdapterDescriptors } from "../agents/shared/agent-adapter.js";
+import { AgentUpdateManager } from "../agents/shared/agent-updates.js";
+import { createAgentSessionService, enabledAgents } from "../agents/shared/agent-factory.js";
+import { AuditLogStore } from "../access/audit-log.js";
+import { BotPreferencesStore } from "../state/bot-preferences.js";
+import { ChannelCommandService } from "../channels/shared/channel-command-service.js";
+import { ChannelTurnService } from "../channels/shared/channel-turn-service.js";
+import { activeSessionSourceForContextKey, ChannelMirrorRegistry } from "../channels/shared/channel-mirror-registry.js";
+import { listThreads as listCodexThreads } from "../agents/codex/codex-state.js";
+import { friendlyErrorText } from "../core/error-messages.js";
+import { clearLogFile, getAgentUpdateLogPath, getConnectorHealth, getConnectorLogPath, getPackageVersion, getUpdateLogPath, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate } from "../support/operations.js";
+import { PromptStore, toPromptEnvelope } from "../state/prompt-store.js";
+import { UnifiedJobStore } from "../state/job-store.js";
+import { buildRuntimeMetrics } from "./metrics.js";
+import { RelayArtifactService } from "./relay-artifact-service.js";
+import { RelayAuthService } from "./relay-auth-service.js";
+import { RelayExternalActivityMonitor } from "./relay-external-activity-monitor.js";
+import { RelayQueueService } from "./relay-queue-service.js";
+import { RuntimeSnapshotCache } from "./runtime-cache.js";
+import { activeSessionPriority, activityToUnifiedJob, agentUpdateStatusToUnified, dedupeJobs, hostLoginCommand, hostLogoutCommand, isPromptTerminalActivity, normalizeMimeType, promptActivityToUnifiedJob, shouldRefreshActiveSessions, taskToUnifiedJob, uploadFileDtos, } from "./relay-runtime-helpers.js";
+import { RelayDashboardService } from "./relay-dashboard-service.js";
+import { capabilitiesOf } from "../channels/shared/bot-rendering.js";
+import { renderSessionInfoPlain, renderSessionUsageRows } from "../channels/shared/session-format.js";
+import { SessionLockStore } from "../access/session-locks.js";
+import { SessionRegistry } from "../state/session-registry.js";
+import { createSupportBundle } from "../support/support-bundle.js";
+import { transcribeAudio } from "../artifacts/voice.js";
+import { WebActivityStore, WebChatStore, } from "../web/web-state.js";
+import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "../core/workspace-policy.js";
+export const WEB_CONTEXT_KEY = "web:dashboard";
+const ACTIVE_CODEX_DISCOVERY_LIMIT = 200;
+const ACTIVE_ACTIVITY_TTL_MS = 6 * 60 * 60 * 1000;
+const MAX_WEB_SESSION_PAGE_SIZE = 50;
+const MAX_CHAT_HISTORY = 250;
+export async function relayRuntimeActiveSessions(runtime) {
+    const sessions = new Map();
+    const knownContexts = runtime.listKnownContextMetadata();
+    const preferences = new BotPreferencesStore(runtime.config.workspace, runtime.config.stateBackend);
+    const addActiveSession = (session) => {
+        const key = runtime.activeSessionKey(session);
+        const existing = sessions.get(key);
+        sessions.set(key, runtime.preferredActiveSession(existing, session));
+    };
+    if (runtime.currentProgress?.status === "running") {
+        addActiveSession({
+            ...runtime.currentProgress,
+            contextKey: runtime.contextKey,
+            sourceContextKey: runtime.contextKey,
+            source: "web",
+            status: "running",
+            queueLength: runtime.queueService.length(),
+            queuePaused: runtime.queueService.isPaused(),
+        });
+    }
+    for (const active of runtime.discoverRunningConnectorSessions()) {
+        addActiveSession(active);
+    }
+    for (const active of runtime.discoverActiveCodexSessions(knownContexts, preferences)) {
+        addActiveSession(active);
+    }
+    for (const meta of knownContexts) {
+        if (meta.contextKey === runtime.contextKey && runtime.currentProgress?.status === "running") {
+            continue;
+        }
+        const active = runtime.externalActiveSession(meta, knownContexts, preferences);
+        if (active) {
+            addActiveSession(active);
+        }
+    }
+    return {
+        sessions: [...sessions.values()].sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt)),
+        updatedAt: new Date().toISOString(),
+    };
+}
+export async function relayRuntimeGetSession(runtime, deferThreadStart) {
+    return runtime.registry.getOrCreate(runtime.contextKey, { deferThreadStart });
+}
+export function relayRuntimeListKnownContextMetadata(runtime) {
+    const contexts = new Map();
+    const add = (meta) => {
+        if (meta?.contextKey) {
+            contexts.set(meta.contextKey, meta);
+        }
+    };
+    for (const meta of runtime.registry.listContexts()) {
+        add(meta);
+    }
+    const sharedRegistry = new SessionRegistry(runtime.config);
+    try {
+        for (const meta of sharedRegistry.listContexts()) {
+            add(meta);
+        }
+    }
+    finally {
+        sharedRegistry.disposeAll();
+    }
+    const current = runtime.registry.get(runtime.contextKey)?.getInfo();
+    if (current) {
+        add({
+            contextKey: runtime.contextKey,
+            agentId: current.agentId,
+            threadId: current.threadId,
+            workspace: current.workspace,
+            model: current.model,
+            reasoningEffort: current.reasoningEffort,
+            launchProfileId: current.nextLaunchProfileId ?? current.launchProfileId,
+            sessionPath: current.sessionPath,
+            updatedAt: Date.now(),
+        });
+    }
+    return [...contexts.values()];
+}
+export function relayRuntimeDiscoverRunningConnectorSessions(runtime) {
+    const active = [];
+    const terminal = new Set();
+    const now = Date.now();
+    for (const event of runtime.activityStore.list({ limit: 500 })) {
+        if (!event.threadId || !event.agentId || !event.contextKey) {
+            continue;
+        }
+        const key = `${event.source}:${event.contextKey}:${event.agentId}:${event.threadId}`;
+        if (isPromptTerminalActivity(event)) {
+            terminal.add(key);
+            continue;
+        }
+        if (event.type !== "prompt_started" || event.status !== "running" || event.source === "cli") {
+            continue;
+        }
+        if (terminal.has(key)) {
+            continue;
+        }
+        const startedMs = Date.parse(event.timestamp);
+        if (!Number.isFinite(startedMs) || now - startedMs > ACTIVE_ACTIVITY_TTL_MS) {
+            continue;
+        }
+        active.push({
+            id: `${event.contextKey}:${event.id}`,
+            contextKey: event.contextKey,
+            sourceContextKey: event.contextKey,
+            source: event.source,
+            status: "running",
+            agentId: event.agentId,
+            agentLabel: event.agentId ? agentLabel(event.agentId) : undefined,
+            threadId: event.threadId,
+            workspace: event.workspace,
+            prompt: event.prompt,
+            startedAt: event.timestamp,
+            updatedAt: event.timestamp,
+            durationMs: Math.max(0, now - startedMs),
+            queueLength: runtime.promptStore.list(event.contextKey).length,
+            queuePaused: runtime.promptStore.isPaused(event.contextKey),
+            detail: event.actor?.label ? `Started by ${event.actor.label}` : undefined,
+        });
+    }
+    return active;
+}
+export function relayRuntimeDiscoverActiveCodexSessions(runtime, knownContexts, preferences) {
+    if (!runtime.config.codexEnabled || !enabledAgents(runtime.config).includes("codex")) {
+        return [];
+    }
+    const capabilities = runtime.capabilitiesForAgent("codex");
+    if (!capabilities.externalActivity) {
+        return [];
+    }
+    const active = [];
+    const nowMs = Date.now();
+    const staleAfterMs = runtime.config.codexExternalBusyStaleMs;
+    for (const thread of listCodexThreads(ACTIVE_CODEX_DISCOVERY_LIMIT)) {
+        if (staleAfterMs > 0 && nowMs - thread.updatedAt.getTime() > staleAfterMs) {
+            continue;
+        }
+        const meta = {
+            contextKey: `cli:codex:${thread.id}`,
+            agentId: "codex",
+            threadId: thread.id,
+            workspace: thread.cwd,
+            model: thread.model ?? undefined,
+            reasoningEffort: thread.reasoningEffort ?? undefined,
+            updatedAt: thread.updatedAt.getTime(),
+        };
+        const session = runtime.externalActiveSession(meta, knownContexts, preferences);
+        if (session) {
+            active.push(session);
+        }
+    }
+    return active;
+}
+export function relayRuntimeExternalActiveSession(runtime, meta, knownContexts, preferences) {
+    if (!meta.threadId) {
+        return null;
+    }
+    const agentId = isAgentId(meta.agentId) ? meta.agentId : runtime.config.defaultAgent;
+    if (!enabledAgents(runtime.config).includes(agentId)) {
+        return null;
+    }
+    const capabilities = runtime.capabilitiesForAgent(agentId);
+    if (!capabilities.externalActivity) {
+        return null;
+    }
+    if (agentId === "codex" &&
+        meta.updatedAt &&
+        runtime.config.codexExternalBusyStaleMs > 0 &&
+        Date.now() - meta.updatedAt > runtime.config.codexExternalBusyStaleMs) {
+        return null;
+    }
+    const snapshot = getExternalSnapshotForSession(runtime.sessionStubForMetadata(meta, agentId, capabilities), runtime.config, {
+        maxEvents: 8,
+    });
+    if (!snapshot?.activity.active) {
+        return null;
+    }
+    const startedAt = snapshot.activity.startedAt?.toISOString() ?? new Date().toISOString();
+    const updatedAt = snapshot.activity.updatedAt?.toISOString() ?? new Date().toISOString();
+    const startedMs = Date.parse(startedAt);
+    const sourceContextKey = `cli:${snapshot.agentId}:${snapshot.threadId}`;
+    const mirrorChannels = runtime.mirrorRegistry.activeMirrorsForThread(snapshot.agentId, snapshot.threadId, knownContexts, preferences);
+    const queueLength = runtime.mirrorRegistry.queueLengthForExternalSource(sourceContextKey, mirrorChannels);
+    const mirrorDetail = mirrorChannels.length > 0
+        ? `Mirroring: ${mirrorChannels.map((mirror) => `${mirror.source} ${mirror.mode}`).join(", ")}`
+        : "Mirroring: none";
+    return {
+        id: `${sourceContextKey}:${snapshot.activity.turnId ?? snapshot.threadId}`,
+        contextKey: sourceContextKey,
+        sourceContextKey,
+        source: "cli",
+        status: "external",
+        agentId: snapshot.agentId,
+        agentLabel: snapshot.agentLabel,
+        threadId: snapshot.threadId,
+        workspace: meta.workspace,
+        prompt: snapshot.latestUserMessage ?? undefined,
+        currentTool: snapshot.latestToolName ?? undefined,
+        lastTool: snapshot.latestToolName ?? undefined,
+        startedAt,
+        updatedAt,
+        durationMs: Number.isFinite(startedMs) ? Math.max(0, Date.now() - startedMs) : 0,
+        queueLength,
+        queuePaused: runtime.mirrorRegistry.queuePausedForExternalSource(sourceContextKey, mirrorChannels),
+        mirrorChannels,
+        detail: `${mirrorDetail} | ${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
+    };
+}
+export function relayRuntimeSessionStubForMetadata(runtime, meta, agentId, capabilities) {
+    const info = {
+        agentId,
+        agentLabel: agentLabel(agentId),
+        threadId: meta.threadId,
+        workspace: meta.workspace,
+        model: meta.model,
+        reasoningEffort: meta.reasoningEffort,
+        launchProfileId: meta.launchProfileId ?? runtime.config.defaultLaunchProfileId,
+        launchProfileLabel: meta.launchProfileId ?? runtime.config.defaultLaunchProfileId,
+        launchProfileBehavior: "-",
+        sandboxMode: "-",
+        approvalPolicy: "-",
+        fastMode: false,
+        unsafeLaunch: false,
+        sessionPath: meta.sessionPath,
+        capabilities,
+    };
+    return {
+        getInfo: () => info,
+        getActiveThreadId: () => meta.threadId,
+    };
+}
+export function relayRuntimeCapabilitiesForAgent(runtime, agentId) {
+    return listAgentAdapterDescriptors().find((descriptor) => descriptor.id === agentId)?.capabilities ?? CODEX_AGENT_CAPABILITIES;
+}
+export function relayRuntimeActiveSessionKey(runtime, session) {
+    return session.threadId ? `${session.agentId ?? "unknown"}:${session.threadId}` : session.id;
+}
+export function relayRuntimePreferredActiveSession(runtime, existing, candidate) {
+    if (!existing) {
+        return candidate;
+    }
+    const existingPriority = activeSessionPriority(existing);
+    const candidatePriority = activeSessionPriority(candidate);
+    if (candidatePriority !== existingPriority) {
+        return candidatePriority > existingPriority ? candidate : existing;
+    }
+    return Date.parse(candidate.updatedAt) >= Date.parse(existing.updatedAt) ? candidate : existing;
+}
+export function relayRuntimeRecordActivity(runtime, input) {
+    return runtime.appendActivity(input);
+}
+export function relayRuntimeAppendActivity(runtime, input) {
+    const event = runtime.activityStore.append(runtime.enrichActivityInput(input));
+    runtime.broadcast({ type: "activity_update", events: runtime.activity({ limit: 50 }) });
+    return event;
+}
+export function relayRuntimeEnrichActivityInput(runtime, input) {
+    return runtime.enrichActivityFields(input);
+}
+export function relayRuntimeEnrichActivityEvent(runtime, event, info) {
+    return runtime.enrichActivityFields(event, info);
+}
+export function relayRuntimeEnrichActivityFields(runtime, event, info) {
+    if (!info) {
+        return !event.threadId && !event.workspace ? { ...event, workspace: runtime.config.workspace } : event;
+    }
+    if (event.threadId && info.threadId && event.threadId === info.threadId) {
+        return { ...event, workspace: event.workspace ?? info.workspace, agentId: event.agentId ?? info.agentId };
+    }
+    if (!event.threadId && !event.workspace) {
+        return { ...event, workspace: runtime.config.workspace };
+    }
+    return event;
+}
+export function relayRuntimeAppendAudit(runtime, input) {
+    return runtime.auditStore.append({ ...input, channelId: "web" });
+}
+export function relayRuntimeUpdateCurrentProgress(runtime, patch = {}) {
+    if (!runtime.currentProgress) {
+        return;
+    }
+    if ("currentTool" in patch) {
+        runtime.currentProgress.currentTool = patch.currentTool;
+        const { currentTool: _currentTool, ...rest } = patch;
+        Object.assign(runtime.currentProgress, rest);
+    }
+    else {
+        Object.assign(runtime.currentProgress, patch);
+    }
+    runtime.currentProgress.durationMs = Date.now() - runtime.currentTurnStartedAt;
+    runtime.currentProgress.updatedAt = new Date().toISOString();
+}
+export function relayRuntimeAddCurrentTool(runtime, toolName) {
+    if (!runtime.currentProgress) {
+        return;
+    }
+    const existing = runtime.currentProgress.tools.find((tool) => tool.name === toolName);
+    if (existing) {
+        existing.count += 1;
+    }
+    else {
+        runtime.currentProgress.tools.push({ name: toolName, count: 1 });
+    }
+    runtime.updateCurrentProgress({ currentTool: toolName, lastTool: toolName });
+}
+export function relayRuntimeBroadcastQueue(runtime) {
+    runtime.broadcast({ type: "queue_update", queue: runtime.queue(), paused: runtime.queuePaused() });
+}
+export function relayRuntimeBroadcastStatus(runtime, message, level = "info") {
+    runtime.broadcast({ type: "status", message, level, at: new Date().toISOString() });
+}
+export function relayRuntimeBroadcast(runtime, event) {
+    for (const subscriber of runtime.subscribers) {
+        try {
+            subscriber(event);
+        }
+        catch {
+            runtime.subscribers.delete(subscriber);
+        }
+    }
+    if (shouldRefreshActiveSessions(event)) {
+        runtime.scheduleActiveSessionsBroadcast();
+    }
+}
+export function relayRuntimeScheduleActiveSessionsBroadcast(runtime) {
+    if (runtime.activeSessionsBroadcastTimer) {
+        return;
+    }
+    const delayMs = Math.max(0, 1_000 - (Date.now() - runtime.activeSessionsLastBroadcastAt));
+    runtime.activeSessionsBroadcastTimer = setTimeout(() => {
+        runtime.activeSessionsBroadcastTimer = null;
+        runtime.activeSessionsLastBroadcastAt = Date.now();
+        void runtime.activeSessions()
+            .then((active) => runtime.broadcast({ type: "active_sessions_update", active }))
+            .catch(() => { });
+    }, delayMs);
+    runtime.activeSessionsBroadcastTimer.unref?.();
+}
+export function relayRuntimePublicInfo(runtime, session) {
+    const info = session.getInfo();
+    const agentId = info.agentId ?? "codex";
+    return {
+        ...info,
+        agentId,
+        agentLabel: info.agentLabel ?? agentLabel(agentId),
+        capabilities: info.capabilities ?? CODEX_AGENT_CAPABILITIES,
+    };
+}

package/dist/runtime/relay-runtime-dashboard.js

@@ -0,0 +1,201 @@
+import { randomUUID } from "node:crypto";
+import { ensureOutDir } from "../artifacts/artifacts.js";
+import { buildFileInstructions, outboxPath, stageFile, } from "../artifacts/attachments.js";
+import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, isAgentId, } from "../agents/shared/agent.js";
+import { getExternalSnapshotForSession } from "../agents/shared/agent-activity.js";
+import { listAgentAdapterDescriptors } from "../agents/shared/agent-adapter.js";
+import { AgentUpdateManager } from "../agents/shared/agent-updates.js";
+import { createAgentSessionService, enabledAgents } from "../agents/shared/agent-factory.js";
+import { AuditLogStore } from "../access/audit-log.js";
+import { BotPreferencesStore } from "../state/bot-preferences.js";
+import { ChannelCommandService } from "../channels/shared/channel-command-service.js";
+import { ChannelTurnService } from "../channels/shared/channel-turn-service.js";
+import { activeSessionSourceForContextKey, ChannelMirrorRegistry } from "../channels/shared/channel-mirror-registry.js";
+import { listThreads as listCodexThreads } from "../agents/codex/codex-state.js";
+import { friendlyErrorText } from "../core/error-messages.js";
+import { clearLogFile, getAgentUpdateLogPath, getConnectorHealth, getConnectorLogPath, getPackageVersion, getUpdateLogPath, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate } from "../support/operations.js";
+import { PromptStore, toPromptEnvelope } from "../state/prompt-store.js";
+import { UnifiedJobStore } from "../state/job-store.js";
+import { buildRuntimeMetrics } from "./metrics.js";
+import { RelayArtifactService } from "./relay-artifact-service.js";
+import { RelayAuthService } from "./relay-auth-service.js";
+import { RelayExternalActivityMonitor } from "./relay-external-activity-monitor.js";
+import { RelayQueueService } from "./relay-queue-service.js";
+import { RuntimeSnapshotCache } from "./runtime-cache.js";
+import { activeSessionPriority, activityToUnifiedJob, agentUpdateStatusToUnified, dedupeJobs, hostLoginCommand, hostLogoutCommand, isPromptTerminalActivity, normalizeMimeType, promptActivityToUnifiedJob, shouldRefreshActiveSessions, taskToUnifiedJob, uploadFileDtos, } from "./relay-runtime-helpers.js";
+import { RelayDashboardService } from "./relay-dashboard-service.js";
+import { capabilitiesOf } from "../channels/shared/bot-rendering.js";
+import { renderSessionInfoPlain, renderSessionUsageRows } from "../channels/shared/session-format.js";
+import { SessionLockStore } from "../access/session-locks.js";
+import { SessionRegistry } from "../state/session-registry.js";
+import { createSupportBundle } from "../support/support-bundle.js";
+import { transcribeAudio } from "../artifacts/voice.js";
+import { WebActivityStore, WebChatStore, } from "../web/web-state.js";
+import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "../core/workspace-policy.js";
+export const WEB_CONTEXT_KEY = "web:dashboard";
+const ACTIVE_CODEX_DISCOVERY_LIMIT = 200;
+const ACTIVE_ACTIVITY_TTL_MS = 6 * 60 * 60 * 1000;
+const MAX_WEB_SESSION_PAGE_SIZE = 50;
+const MAX_CHAT_HISTORY = 250;
+export function relayRuntimeSubscribe(runtime, callback) {
+    runtime.subscribers.add(callback);
+    void runtime.snapshot().then((data) => callback({ type: "snapshot", data })).catch(() => { });
+    void runtime.chatHistory().then((messages) => callback({ type: "chat_history", messages })).catch(() => { });
+    void runtime.activeSessions().then((active) => callback({ type: "active_sessions_update", active })).catch(() => { });
+    callback({ type: "activity_update", events: runtime.activity({ limit: 50 }) });
+    return () => runtime.subscribers.delete(callback);
+}
+export async function relayRuntimeSnapshot(runtime) {
+    const session = await runtime.getSession(true);
+    const info = runtime.publicInfo(session);
+    return {
+        session: info,
+        sessionText: renderSessionInfoPlain(info),
+        queue: runtime.queue(),
+        queuePaused: runtime.queuePaused(),
+        processing: session.isProcessing(),
+        enabledAgents: enabledAgents(runtime.config),
+        workspaces: filterAllowedWorkspaces(session.listWorkspaces(), runtime.config),
+    };
+}
+export async function relayRuntimeStatus(runtime) {
+    const cliOptions = runtime.cliPathOptions();
+    const [health, versionChecks, snapshot] = await Promise.all([
+        getConnectorHealth(cliOptions),
+        getVersionChecks(cliOptions),
+        runtime.snapshot(),
+    ]);
+    return {
+        health,
+        versionChecks,
+        snapshot,
+    };
+}
+export async function relayRuntimeBootstrapStatus(runtime) {
+    return {
+        health: {
+            version: await getPackageVersion(),
+            state: await readConnectorState(),
+        },
+        snapshot: await runtime.snapshot(),
+    };
+}
+export async function relayRuntimeVersion(runtime) {
+    return runtime.dashboardService.version();
+}
+export async function relayRuntimeDiagnostics(runtime) {
+    return runtime.dashboardService.diagnostics();
+}
+export async function relayRuntimeAdapterHealth(runtime) {
+    return runtime.dashboardService.adapterHealth();
+}
+export function relayRuntimePermissions(runtime) {
+    return {
+        mode: "users",
+        message: "Access is managed by NordRelay users, groups, Telegram identities, Telegram chat access records, Discord identities, and Discord channel access records.",
+    };
+}
+export async function relayRuntimeMetrics(runtime) {
+    const [active, jobs] = await Promise.all([
+        runtime.activeSessions(),
+        runtime.jobs(),
+    ]);
+    return buildRuntimeMetrics({
+        queueLength: runtime.queueService.length(),
+        queuePaused: runtime.queueService.isPaused(),
+        activeTurnCount: active.sessions.length,
+        jobs: jobs.jobs,
+        activity: runtime.activity({ limit: 500 }),
+    });
+}
+export function relayRuntimeAudit(runtime, options = 50) {
+    return runtime.auditStore.list(options);
+}
+export async function relayRuntimeSupportBundle(runtime, actor) {
+    const bundle = await createSupportBundle({
+        config: runtime.config,
+        diagnostics: await runtime.diagnostics(),
+        adapterHealth: await runtime.adapterHealth(),
+        auditEvents: runtime.auditStore.list(100),
+        agentUpdateJobs: runtime.agentUpdates.list(),
+        source: "web",
+    });
+    runtime.appendActivity({
+        source: "web",
+        status: "info",
+        type: "diagnostics_bundle_exported",
+        threadId: null,
+        workspace: runtime.config.workspace,
+        actor,
+        detail: bundle.path,
+    });
+    runtime.appendAudit({
+        action: "command",
+        status: "ok",
+        contextKey: runtime.contextKey,
+        actor,
+        description: "export diagnostics bundle",
+        detail: bundle.path,
+    });
+    return bundle;
+}
+export async function relayRuntimeLogs(runtime, target = "connector", lines = 100) {
+    if (target === "update") {
+        return readFormattedLogTail(lines, getUpdateLogPath());
+    }
+    if (target === "agent-updates") {
+        return readFormattedLogTail(lines, getAgentUpdateLogPath());
+    }
+    return readFormattedLogTail(lines);
+}
+export function relayRuntimeClearLogs(runtime, target = "connector", actor) {
+    const result = clearLogFile(target === "update" ? getUpdateLogPath() : target === "agent-updates" ? getAgentUpdateLogPath() : getConnectorLogPath());
+    runtime.appendActivity({
+        source: "web",
+        status: "info",
+        type: "logs_cleared",
+        threadId: null,
+        workspace: runtime.config.workspace,
+        actor,
+        detail: `Cleared ${target} log.`,
+    });
+    runtime.appendAudit({
+        action: "command",
+        status: "ok",
+        contextKey: runtime.contextKey,
+        actor,
+        description: `clear ${target} log`,
+        detail: result.filePath,
+    });
+    return { ok: true, filePath: result.filePath, clearedAt: result.clearedAt.toISOString() };
+}
+export function relayRuntimeRestartConnector(runtime, actor) {
+    spawnConnectorRestart();
+    runtime.broadcastStatus("Restart requested. The dashboard may disconnect briefly.", "warn");
+    runtime.appendActivity({
+        source: "web",
+        status: "info",
+        type: "restart_requested",
+        threadId: null,
+        workspace: runtime.config.workspace,
+        actor,
+        detail: "Dashboard requested a connector restart.",
+    });
+    runtime.appendAudit({
+        action: "command",
+        status: "ok",
+        contextKey: runtime.contextKey,
+        actor,
+        description: "restart connector",
+    });
+    return { ok: true, message: "Restart requested." };
+}
+export function relayRuntimeDispose(runtime) {
+    if (runtime.externalMonitor) {
+        clearInterval(runtime.externalMonitor);
+    }
+    runtime.dashboardService.stopBackgroundRefresh();
+    runtime.agentUpdates.cancelAll();
+    runtime.registry.disposeAll();
+    runtime.subscribers.clear();
+}