@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/session/daemon/daemon-session.js

@@ -0,0 +1,179 @@
+import { getPidLockInfo } from "../../pid-lock.js";
+import { generateLocalPairingOffer } from "../../pairing-offer.js";
+import { collectDaemonDiagnostics, } from "./diagnostics.js";
+import { DaemonSelfUpdateSessionController } from "./daemon-self-update-session-controller.js";
+/**
+ * A client's read surface for the daemon process itself: its runtime status
+ * (pid-lock start time, listen address, relay config, provider availability) and
+ * a fresh local pairing offer for connecting a new client. Owns the `daemon.*`
+ * RPCs. Reaches no state beyond the never-mutated runtime values injected at
+ * construction and the outbound channel.
+ */
+export class DaemonSession {
+    constructor(options) {
+        this.host = options.host;
+        this.clientId = options.clientId;
+        this.paseoHome = options.paseoHome;
+        this.serverId = options.serverId;
+        this.daemonVersion = options.daemonVersion;
+        this.daemonRuntimeConfig = options.daemonRuntimeConfig;
+        this.listAgents = options.listAgents;
+        this.listProjects = options.listProjects;
+        this.listWorkspaces = options.listWorkspaces;
+        this.listProviderAvailability = options.listProviderAvailability;
+        this.getWebSocketRuntimeMetrics = options.getWebSocketRuntimeMetrics ?? (() => null);
+        this.providerProbeBudgetMs =
+            options.providerProbeBudgetMs ?? DaemonSession.DEFAULT_PROVIDER_PROBE_BUDGET_MS;
+        this.logger = options.logger;
+        this.selfUpdate = new DaemonSelfUpdateSessionController({
+            clientId: this.clientId,
+            daemonVersion: this.daemonVersion ?? null,
+            emit: (msg) => this.host.emit(msg),
+            emitLifecycleIntent: (intent) => this.host.emitLifecycleIntent(intent),
+            sessionLogger: this.logger,
+        });
+    }
+    async listProviderAvailabilityBounded() {
+        let timer;
+        const budget = new Promise((resolve) => {
+            timer = setTimeout(() => resolve("timeout"), this.providerProbeBudgetMs);
+            timer.unref?.();
+        });
+        try {
+            const outcome = await Promise.race([this.listProviderAvailability(), budget]);
+            if (outcome === "timeout") {
+                this.logger.warn({ budgetMs: this.providerProbeBudgetMs }, "Provider availability probe exceeded its budget; answering daemon status without it");
+                return { providers: [], timedOut: true };
+            }
+            return { providers: outcome, timedOut: false };
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
+    async handleGetStatusRequest(msg) {
+        try {
+            const pidInfo = await getPidLockInfo(this.paseoHome);
+            const providers = (await this.listProviderAvailabilityBounded()).providers.map((p) => ({
+                provider: p.provider,
+                available: p.available,
+                error: p.error ?? null,
+            }));
+            this.host.emit({
+                type: "daemon.get_status.response",
+                payload: {
+                    requestId: msg.requestId,
+                    serverId: this.serverId ?? "",
+                    version: this.daemonVersion ?? null,
+                    pid: process.pid,
+                    nodePath: process.execPath,
+                    startedAt: pidInfo?.startedAt ?? null,
+                    listen: this.daemonRuntimeConfig?.listen ?? null,
+                    relay: this.daemonRuntimeConfig?.relay ?? null,
+                    providers,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to handle daemon status request");
+            this.host.emit({
+                type: "daemon.get_status.response",
+                payload: {
+                    requestId: msg.requestId,
+                    serverId: this.serverId ?? "",
+                    version: this.daemonVersion ?? null,
+                    pid: process.pid,
+                    nodePath: process.execPath,
+                    startedAt: null,
+                    listen: null,
+                    relay: null,
+                    providers: [],
+                },
+            });
+        }
+    }
+    async handleGetPairingOfferRequest(msg) {
+        try {
+            const relay = this.daemonRuntimeConfig?.relay;
+            const pairing = await generateLocalPairingOffer({
+                paseoHome: this.paseoHome,
+                relayEnabled: relay?.enabled ?? true,
+                relayEndpoint: relay?.endpoint,
+                relayPublicEndpoint: relay?.publicEndpoint,
+                relayUseTls: relay?.useTls,
+                relayPublicUseTls: relay?.publicUseTls,
+                appBaseUrl: this.daemonRuntimeConfig?.appBaseUrl,
+                includeQr: true,
+                logger: this.logger,
+            });
+            this.host.emit({
+                type: "daemon.get_pairing_offer.response",
+                payload: {
+                    requestId: msg.requestId,
+                    url: pairing.url ?? "",
+                    qr: pairing.qr ?? null,
+                    relayEnabled: pairing.relayEnabled,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to handle daemon pairing offer request");
+            this.host.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: msg.requestId,
+                    requestType: "daemon.get_pairing_offer.request",
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    async handleDiagnosticsRequest(msg) {
+        try {
+            const diagnostic = await collectDaemonDiagnostics({
+                paseoHome: this.paseoHome,
+                serverId: this.serverId,
+                daemonVersion: this.daemonVersion,
+                daemonRuntimeConfig: this.daemonRuntimeConfig,
+                listAgents: this.listAgents,
+                listProjects: this.listProjects,
+                listWorkspaces: this.listWorkspaces,
+                listProviderAvailability: this.listProviderAvailability,
+                getWebSocketRuntimeMetrics: this.getWebSocketRuntimeMetrics,
+                logger: this.logger,
+            });
+            this.host.emit({
+                type: "diagnostics.response",
+                payload: {
+                    requestId: msg.requestId,
+                    diagnostic,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to handle diagnostics request");
+            this.host.emit({
+                type: "diagnostics.response",
+                payload: {
+                    requestId: msg.requestId,
+                    diagnostic: `Paseo diagnostics\n  Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            });
+        }
+    }
+    async handleUpdateRequest(msg) {
+        await this.selfUpdate.dispatch(msg);
+    }
+}
+/**
+ * Provider availability is probed per provider and each probe can shell out, so the
+ * total cost scales with how many providers are registered -- measured at ~15s with 44
+ * of them. Everything else in the status payload is instant and is what callers
+ * actually block on, so the provider block is best-effort: if it has not resolved
+ * within this budget we answer without it rather than making the whole RPC time out.
+ * The CLI's own probe budget sits above this. See paseo#2.
+ */
+DaemonSession.DEFAULT_PROVIDER_PROBE_BUDGET_MS = 2000;
+//# sourceMappingURL=daemon-session.js.map

package/dist/server/server/session/daemon/diagnostics.d.ts

@@ -0,0 +1,41 @@
+import type pino from "pino";
+import type { ManagedAgent, ProviderAvailability } from "../../agent/agent-manager.js";
+import type { WebSocketRuntimeDiagnosticSnapshot } from "../../websocket/runtime-metrics.js";
+import type { PersistedProjectRecord, PersistedWorkspaceRecord } from "../../workspace-registry.js";
+import type { DaemonRuntimeConfig } from "./daemon-session.js";
+export interface DaemonDiagnosticsOptions {
+    paseoHome: string;
+    serverId: string | undefined;
+    daemonVersion: string | undefined;
+    daemonRuntimeConfig: DaemonRuntimeConfig | undefined;
+    listAgents: () => ManagedAgent[];
+    listProjects: () => Promise<PersistedProjectRecord[]>;
+    listWorkspaces: () => Promise<PersistedWorkspaceRecord[]>;
+    listProviderAvailability: () => Promise<ProviderAvailability[]>;
+    getWebSocketRuntimeMetrics: () => DaemonWebSocketRuntimeDiagnosticSnapshot | null;
+    logger: pino.Logger;
+}
+interface DiagnosticWebSocketRuntimeMetrics {
+    terminalDirectorySubscriptionCount: number;
+    terminalSubscriptionCount: number;
+    inflightRequests: number;
+    peakInflightRequests: number;
+    checkoutDiffTargetCount: number;
+    checkoutDiffSubscriptionCount: number;
+    checkoutDiffWatcherCount: number;
+    checkoutDiffFallbackRefreshTargetCount: number;
+}
+interface DiagnosticAgentRuntimeMetrics {
+    total: number;
+    byLifecycle: Record<string, number>;
+    withActiveForegroundTurn: number;
+    timelineStats: {
+        totalItems: number;
+        maxItemsPerAgent: number;
+    };
+}
+export type DaemonWebSocketRuntimeDiagnosticSnapshot = WebSocketRuntimeDiagnosticSnapshot<DiagnosticWebSocketRuntimeMetrics, DiagnosticAgentRuntimeMetrics>;
+export declare function collectDaemonDiagnostics(options: DaemonDiagnosticsOptions): Promise<string>;
+export declare function redactDiagnostic(value: string, options?: Partial<DaemonDiagnosticsOptions>): string;
+export {};
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/server/server/session/daemon/diagnostics.js

@@ -0,0 +1,431 @@
+import { open, statfs } from "node:fs/promises";
+import { cpus, freemem, loadavg, platform, release, totalmem, type } from "node:os";
+import path from "node:path";
+import { execCommand } from "../../../utils/spawn.js";
+const TOOL_TIMEOUT_MS = 3000;
+const TOOL_OUTPUT_LIMIT = 512;
+const LOG_TAIL_LINES = 80;
+const LOG_TAIL_MAX_BYTES = 64 * 1024;
+export async function collectDaemonDiagnostics(options) {
+    const sections = [
+        formatSection("Paseo diagnostics", [
+            { label: "Collected at", value: new Date().toISOString() },
+            { label: "Server ID", value: options.serverId ?? "unknown" },
+            { label: "Daemon version", value: options.daemonVersion ?? "unknown" },
+        ]),
+    ];
+    sections.push(await safeSection("Daemon process", () => collectProcessEntries(options), options.logger));
+    sections.push(await safeSection("Runtime config", () => collectRuntimeConfigEntries(options), options.logger));
+    sections.push(await safeSection("System", collectSystemEntries, options.logger));
+    sections.push(await safeSection("Disk", () => collectDiskEntries(options), options.logger));
+    sections.push(await safeSection("Agents", () => collectAgentEntries(options), options.logger));
+    sections.push(await safeSection("Workspaces", () => collectWorkspaceEntries(options), options.logger));
+    sections.push(await safeSection("Providers", () => collectProviderEntries(options), options.logger));
+    sections.push(await safeSection("WebSocket runtime metrics", () => collectWebSocketRuntimeEntries(options), options.logger));
+    sections.push(await safeSection("Tools", collectToolEntries, options.logger));
+    sections.push(await safeLogTailSection(options));
+    return redactDiagnostic(sections.filter(Boolean).join("\n\n"), options);
+}
+async function safeSection(title, collect, logger) {
+    try {
+        return formatSection(title, await collect());
+    }
+    catch (error) {
+        logger.debug({ err: error, title }, "diagnostic section failed");
+        return formatSection(title, [{ label: "Error", value: toErrorMessage(error) }]);
+    }
+}
+function formatSection(title, entries) {
+    return [title, ...entries.map((entry) => `  ${entry.label}: ${entry.value}`)].join("\n");
+}
+function collectProcessEntries(options) {
+    const memory = process.memoryUsage();
+    return [
+        { label: "PID", value: String(process.pid) },
+        { label: "Node", value: process.version },
+        { label: "Node path", value: process.execPath },
+        { label: "PATH", value: getEnvValue("PATH", "Path") ?? "unset" },
+        { label: "Shell", value: formatDaemonShell() },
+        { label: "Uptime", value: formatDurationMs(process.uptime() * 1000) },
+        { label: "Paseo home", value: options.paseoHome },
+        { label: "RSS", value: formatBytes(memory.rss) },
+        {
+            label: "Heap used",
+            value: `${formatBytes(memory.heapUsed)} / ${formatBytes(memory.heapTotal)}`,
+        },
+        { label: "External", value: formatBytes(memory.external) },
+    ];
+}
+function collectRuntimeConfigEntries(options) {
+    const relay = options.daemonRuntimeConfig?.relay ?? null;
+    return [
+        { label: "Listen", value: formatListenKind(options.daemonRuntimeConfig?.listen ?? null) },
+        { label: "Relay enabled", value: relay ? String(relay.enabled) : "false" },
+        { label: "Relay endpoint configured", value: relay?.endpoint ? "true" : "false" },
+        { label: "Relay public endpoint configured", value: relay?.publicEndpoint ? "true" : "false" },
+        { label: "Relay TLS", value: relay ? String(relay.useTls) : "n/a" },
+        { label: "Relay public TLS", value: relay ? String(relay.publicUseTls) : "n/a" },
+    ];
+}
+function collectSystemEntries() {
+    const loads = loadavg();
+    return [
+        { label: "OS", value: `${type()} ${release()}` },
+        { label: "Platform", value: `${platform()} ${process.arch}` },
+        { label: "CPU cores", value: String(cpus().length) },
+        { label: "Load avg", value: loads.map((value) => value.toFixed(2)).join(", ") },
+        { label: "Memory free", value: `${formatBytes(freemem())} / ${formatBytes(totalmem())}` },
+    ];
+}
+async function collectDiskEntries(options) {
+    const stats = await statfs(options.paseoHome);
+    const freeBytes = stats.bavail * stats.bsize;
+    const totalBytes = stats.blocks * stats.bsize;
+    return [
+        { label: "Path", value: options.paseoHome },
+        { label: "Free", value: `${formatBytes(freeBytes)} / ${formatBytes(totalBytes)}` },
+    ];
+}
+function collectAgentEntries(options) {
+    const agents = options.listAgents();
+    return [
+        { label: "Total", value: String(agents.length) },
+        { label: "By provider", value: formatCountMap(countBy(agents, (agent) => agent.provider)) },
+        { label: "By lifecycle", value: formatCountMap(countBy(agents, (agent) => agent.lifecycle)) },
+        {
+            label: "Pending permissions",
+            value: String(agents.reduce((total, agent) => total + (agent.pendingPermissions?.size ?? 0), 0)),
+        },
+    ];
+}
+async function collectWorkspaceEntries(options) {
+    const [projects, workspaces] = await Promise.all([
+        options.listProjects(),
+        options.listWorkspaces(),
+    ]);
+    const activeProjects = projects.filter((project) => !project.archivedAt);
+    const activeWorkspaces = workspaces.filter((workspace) => !workspace.archivedAt);
+    return [
+        { label: "Projects", value: `${activeProjects.length} active / ${projects.length} total` },
+        {
+            label: "Workspaces",
+            value: `${activeWorkspaces.length} active / ${workspaces.length} total`,
+        },
+        {
+            label: "Workspaces by kind",
+            value: formatCountMap(countBy(activeWorkspaces, (workspace) => workspace.kind)),
+        },
+    ];
+}
+async function collectProviderEntries(options) {
+    const providers = await options.listProviderAvailability();
+    return [
+        { label: "Total", value: String(providers.length) },
+        {
+            label: "Available",
+            value: String(providers.filter((provider) => provider.available).length),
+        },
+        {
+            label: "Unavailable",
+            value: providers
+                .filter((provider) => !provider.available)
+                .map((provider) => provider.error ? `${provider.provider} (${provider.error})` : provider.provider)
+                .join(", ") || "none",
+        },
+    ];
+}
+async function collectToolEntries() {
+    const [git, gh] = await Promise.all([
+        checkTool("git", ["--version"]),
+        checkTool("gh", ["--version"]),
+    ]);
+    return [
+        { label: "git", value: git },
+        { label: "gh", value: gh },
+    ];
+}
+function collectWebSocketRuntimeEntries(options) {
+    const snapshot = options.getWebSocketRuntimeMetrics();
+    if (!snapshot) {
+        return [{ label: "Status", value: "no runtime metrics window has been flushed yet" }];
+    }
+    const runtime = snapshot.runtime;
+    const agents = snapshot.agents;
+    return [
+        { label: "Collected at", value: snapshot.collectedAt },
+        { label: "Window", value: formatDurationMs(snapshot.windowMs) },
+        { label: "Process uptime", value: formatDurationMs(snapshot.uptimeSeconds * 1000) },
+        {
+            label: "Process memory",
+            value: [
+                `rss=${formatBytes(snapshot.memory.rss)}`,
+                `heap=${formatBytes(snapshot.memory.heapUsed)} / ${formatBytes(snapshot.memory.heapTotal)}`,
+                `external=${formatBytes(snapshot.memory.external)}`,
+                `arrayBuffers=${formatBytes(snapshot.memory.arrayBuffers)}`,
+            ].join(", "),
+        },
+        { label: "Final", value: String(snapshot.final) },
+        {
+            label: "Sessions",
+            value: [
+                `active=${snapshot.sessions.activeConnections}`,
+                `externalKeys=${snapshot.sessions.externalSessionKeys}`,
+                `reconnectGrace=${snapshot.sessions.reconnectGraceSessions}`,
+            ].join(", "),
+        },
+        {
+            label: "Sockets",
+            value: [
+                `active=${snapshot.sockets.activeSockets}`,
+                `pending=${snapshot.sockets.pendingConnections}`,
+            ].join(", "),
+        },
+        {
+            label: "Runtime requests",
+            value: [
+                `inflight=${formatNumberMetric(runtime.inflightRequests)}`,
+                `peakInflight=${formatNumberMetric(runtime.peakInflightRequests)}`,
+            ].join(", "),
+        },
+        {
+            label: "Terminal subscriptions",
+            value: [
+                `terminals=${formatNumberMetric(runtime.terminalSubscriptionCount)}`,
+                `directories=${formatNumberMetric(runtime.terminalDirectorySubscriptionCount)}`,
+            ].join(", "),
+        },
+        {
+            label: "Checkout diff",
+            value: [
+                `targets=${formatNumberMetric(runtime.checkoutDiffTargetCount)}`,
+                `subscriptions=${formatNumberMetric(runtime.checkoutDiffSubscriptionCount)}`,
+                `watchers=${formatNumberMetric(runtime.checkoutDiffWatcherCount)}`,
+                `fallbackRefreshTargets=${formatNumberMetric(runtime.checkoutDiffFallbackRefreshTargetCount)}`,
+            ].join(", "),
+        },
+        {
+            label: "Buffered amount",
+            value: `p95=${formatBytes(snapshot.bufferedAmount.p95)}, max=${formatBytes(snapshot.bufferedAmount.max)}`,
+        },
+        { label: "Event loop delay", value: formatEventLoopDelay(snapshot.eventLoopDelay) },
+        { label: "Latency", value: formatLatencyStats(snapshot.latency) },
+        { label: "Inbound messages", value: formatTopCounts(snapshot.inboundMessageTypesTop) },
+        {
+            label: "Inbound session requests",
+            value: formatTopCounts(snapshot.inboundSessionRequestTypesTop),
+        },
+        { label: "Outbound messages", value: formatTopCounts(snapshot.outboundMessageTypesTop) },
+        {
+            label: "Outbound session messages",
+            value: formatTopCounts(snapshot.outboundSessionMessageTypesTop),
+        },
+        { label: "Agent streams", value: formatTopCounts(snapshot.outboundAgentStreamTypesTop) },
+        { label: "Agent stream agents", value: formatTopCounts(snapshot.outboundAgentStreamAgentsTop) },
+        { label: "Binary frames", value: formatTopCounts(snapshot.outboundBinaryFrameTypesTop) },
+        { label: "Counters", value: formatNonZeroNumberRecord(snapshot.counters) },
+        {
+            label: "Agent metrics",
+            value: [
+                `total=${formatNumberMetric(agents.total)}`,
+                `activeForegroundTurns=${formatNumberMetric(agents.withActiveForegroundTurn)}`,
+            ].join(", "),
+        },
+        { label: "Agent lifecycle", value: formatNumberRecord(agents.byLifecycle) },
+        {
+            label: "Agent timelines",
+            value: [
+                `items=${formatNumberMetric(agents.timelineStats?.totalItems)}`,
+                `maxPerAgent=${formatNumberMetric(agents.timelineStats?.maxItemsPerAgent)}`,
+            ].join(", "),
+        },
+    ];
+}
+function formatTopCounts(counts) {
+    if (counts.length === 0)
+        return "none";
+    return counts.map(([key, count]) => `${key}=${count}`).join(", ");
+}
+function formatLatencyStats(stats) {
+    if (stats.length === 0)
+        return "none";
+    return stats
+        .map((stat) => `${stat.type} count=${stat.count} p50=${formatMilliseconds(stat.p50Ms)} max=${formatMilliseconds(stat.maxMs)} total=${formatMilliseconds(stat.totalMs)}`)
+        .join("; ");
+}
+function formatEventLoopDelay(stats) {
+    if (!stats)
+        return "unavailable";
+    return `p50=${formatMilliseconds(stats.p50Ms)}, p99=${formatMilliseconds(stats.p99Ms)}, max=${formatMilliseconds(stats.maxMs)}`;
+}
+function formatNumberRecord(record) {
+    if (!record)
+        return "unknown";
+    const entries = Object.entries(record).filter(([, value]) => Number.isFinite(value));
+    if (entries.length === 0)
+        return "none";
+    return entries
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${value}`)
+        .join(", ");
+}
+function formatNonZeroNumberRecord(record) {
+    const entries = Object.entries(record).filter(([, value]) => Number.isFinite(value) && value !== 0);
+    if (entries.length === 0)
+        return "none";
+    return entries
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${value}`)
+        .join(", ");
+}
+function formatNumberMetric(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return "unknown";
+    return String(value);
+}
+function formatMilliseconds(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return "unknown";
+    return `${Math.round(ms)}ms`;
+}
+async function checkTool(command, args) {
+    try {
+        const result = await execCommand(command, args, {
+            timeout: TOOL_TIMEOUT_MS,
+            maxBuffer: TOOL_OUTPUT_LIMIT * 2,
+        });
+        const output = truncateForDiagnostic((result.stdout || result.stderr).trim(), TOOL_OUTPUT_LIMIT);
+        return output || "ok";
+    }
+    catch (error) {
+        return `error: ${truncateForDiagnostic(toErrorMessage(error), TOOL_OUTPUT_LIMIT)}`;
+    }
+}
+async function safeLogTailSection(options) {
+    const logPath = path.join(options.paseoHome, "daemon.log");
+    try {
+        const tail = await tailFile(logPath, LOG_TAIL_LINES, LOG_TAIL_MAX_BYTES);
+        return ["Daemon log tail", `  Path: ${logPath}`, tail ? tail : "  No log lines found"].join("\n");
+    }
+    catch (error) {
+        options.logger.debug({ err: error, logPath }, "diagnostic log tail failed");
+        return ["Daemon log tail", `  Path: ${logPath}`, `  Error: ${toErrorMessage(error)}`].join("\n");
+    }
+}
+async function tailFile(filePath, lines, maxBytes) {
+    const handle = await open(filePath, "r");
+    try {
+        const stats = await handle.stat();
+        const length = Math.min(stats.size, maxBytes);
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, stats.size - length);
+        return buffer
+            .toString("utf8")
+            .split("\n")
+            .filter(Boolean)
+            .slice(-lines)
+            .map((line) => `  ${line}`)
+            .join("\n");
+    }
+    finally {
+        await handle.close();
+    }
+}
+function formatListenKind(listen) {
+    if (!listen)
+        return "not configured";
+    if (listen.startsWith("unix://") || listen.startsWith("/"))
+        return "local socket";
+    if (listen.startsWith("pipe://") || listen.startsWith("\\\\.\\pipe\\"))
+        return "local pipe";
+    return "direct TCP";
+}
+function countBy(items, getKey) {
+    const counts = new Map();
+    for (const item of items) {
+        const key = getKey(item) || "unknown";
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
+function formatCountMap(counts) {
+    if (counts.size === 0)
+        return "none";
+    return [...counts.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, count]) => `${key}=${count}`)
+        .join(", ");
+}
+function formatDurationMs(ms) {
+    const seconds = Math.max(0, Math.round(ms / 1000));
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const remainingSeconds = seconds % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${remainingSeconds}s`;
+    if (minutes > 0)
+        return `${minutes}m ${remainingSeconds}s`;
+    return `${remainingSeconds}s`;
+}
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return "unknown";
+    const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    return `${value.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}
+function truncateForDiagnostic(value, maxLength) {
+    const trimmed = value.trim();
+    if (trimmed.length <= maxLength)
+        return trimmed;
+    return `${trimmed.slice(0, maxLength)}...(truncated)`;
+}
+function formatDaemonShell() {
+    const shell = getEnvValue("SHELL");
+    if (shell)
+        return `SHELL=${shell}`;
+    const comspec = getEnvValue("ComSpec", "COMSPEC");
+    if (comspec)
+        return `ComSpec=${comspec}`;
+    return "unset";
+}
+function getEnvValue(...names) {
+    for (const name of names) {
+        const value = process.env[name];
+        if (value)
+            return value;
+    }
+    const lowerNames = new Set(names.map((name) => name.toLowerCase()));
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value && lowerNames.has(key.toLowerCase()))
+            return value;
+    }
+    return null;
+}
+function toErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    return String(error);
+}
+export function redactDiagnostic(value, options) {
+    let redacted = value;
+    const sensitiveValues = [
+        options?.daemonRuntimeConfig?.listen,
+        options?.daemonRuntimeConfig?.relay?.endpoint,
+        options?.daemonRuntimeConfig?.relay?.publicEndpoint,
+    ].filter((item) => Boolean(item));
+    for (const sensitive of sensitiveValues) {
+        redacted = redacted.split(sensitive).join("[redacted]");
+    }
+    return redacted
+        .replace(/paseo:\/\/\S+/gi, "paseo://[redacted]")
+        .replace(/([?&](?:password|token|secret|key|publicKey|daemonPublicKeyB64)=)[^&\s"']+/gi, "$1[redacted]")
+        .replace(/((?:password|token|secret|authorization|api[_-]?key|daemonPublicKeyB64|relayKey)\s*[:=]\s*)("[^"]+"|'[^']+'|[^\s,}]+)/gi, "$1[redacted]");
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/server/server/session/daemon/install-origin.d.ts

@@ -0,0 +1,7 @@
+import { type NpmGlobalPaseoInstall } from "./npm-global-cli.js";
+export interface DaemonInstallOriginRuntime {
+    resolveCurrentServerPackageRoot(): string | null;
+}
+export declare const daemonInstallOriginRuntime: DaemonInstallOriginRuntime;
+export declare function validateDaemonInstallOrigin(install: NpmGlobalPaseoInstall, daemonVersion: string | null, runtime?: DaemonInstallOriginRuntime): string | null;
+//# sourceMappingURL=install-origin.d.ts.map