ucu-mcp 0.2.0 → 0.3.1

package/dist/src/util/metrics.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Tool-call latency ring buffer for performance observability.
+ *
+ * Keeps the last 1000 durationMs samples per tool name and exposes
+ * p50/p95/max/mean stats through the `doctor` tool.
+ *
+ * Singleton instance: import `metrics` and call `record()` on every
+ * completed tool call. Tests that need isolation can construct their own
+ * Metrics instance.
+ */
+export interface MetricStats {
+    count: number;
+    p50: number;
+    p95: number;
+    max: number;
+    mean: number;
+}
+export declare class Metrics {
+    private buffers;
+    private order;
+    private writeIndex;
+    private totalWrites;
+    /** Record a durationMs sample for the named tool. */
+    record(toolName: string, durationMs: number): void;
+    /** Get stats for one tool, or aggregate across all tools. */
+    stats(toolName?: string): MetricStats;
+    /** Stats for every tracked tool. */
+    byTool(): Record<string, MetricStats>;
+    /** Clear all recorded samples. Mostly for tests. */
+    reset(): void;
+    private liveSamples;
+    private computeStats;
+    /** Nearest-rank percentile on a pre-sorted ascending array. */
+    private percentile;
+}
+/** Singleton shared across the process. */
+export declare const metrics: Metrics;

package/dist/src/util/metrics.js

@@ -0,0 +1,97 @@
+/**
+ * Tool-call latency ring buffer for performance observability.
+ *
+ * Keeps the last 1000 durationMs samples per tool name and exposes
+ * p50/p95/max/mean stats through the `doctor` tool.
+ *
+ * Singleton instance: import `metrics` and call `record()` on every
+ * completed tool call. Tests that need isolation can construct their own
+ * Metrics instance.
+ */
+const RING_SIZE = 1000;
+export class Metrics {
+    buffers = new Map();
+    order = [];
+    writeIndex = new Map();
+    totalWrites = new Map();
+    /** Record a durationMs sample for the named tool. */
+    record(toolName, durationMs) {
+        let buf = this.buffers.get(toolName);
+        if (!buf) {
+            buf = new Array(RING_SIZE).fill(0);
+            this.buffers.set(toolName, buf);
+            this.order.push(toolName);
+            this.writeIndex.set(toolName, 0);
+            this.totalWrites.set(toolName, 0);
+        }
+        const idx = this.writeIndex.get(toolName);
+        buf[idx] = durationMs;
+        this.writeIndex.set(toolName, (idx + 1) % RING_SIZE);
+        this.totalWrites.set(toolName, (this.totalWrites.get(toolName) ?? 0) + 1);
+    }
+    /** Get stats for one tool, or aggregate across all tools. */
+    stats(toolName) {
+        if (toolName !== undefined) {
+            return this.computeStats(this.liveSamples(toolName));
+        }
+        const all = [];
+        for (const name of this.order) {
+            all.push(...this.liveSamples(name));
+        }
+        return this.computeStats(all);
+    }
+    /** Stats for every tracked tool. */
+    byTool() {
+        const out = {};
+        for (const name of this.order) {
+            const samples = this.liveSamples(name);
+            if (samples.length > 0) {
+                out[name] = this.computeStats(samples);
+            }
+        }
+        return out;
+    }
+    /** Clear all recorded samples. Mostly for tests. */
+    reset() {
+        this.buffers.clear();
+        this.order.length = 0;
+        this.writeIndex.clear();
+        this.totalWrites.clear();
+    }
+    liveSamples(toolName) {
+        const buf = this.buffers.get(toolName);
+        if (!buf)
+            return [];
+        const total = this.totalWrites.get(toolName) ?? 0;
+        if (total < RING_SIZE) {
+            return buf.slice(0, total);
+        }
+        // Ring is full — all RING_SIZE slots contain the most recent samples.
+        return buf.slice();
+    }
+    computeStats(samples) {
+        if (samples.length === 0) {
+            return { count: 0, p50: 0, p95: 0, max: 0, mean: 0 };
+        }
+        const sorted = [...samples].sort((a, b) => a - b);
+        const sum = sorted.reduce((acc, v) => acc + v, 0);
+        const round = (n) => Math.round(n * 10) / 10;
+        return {
+            count: sorted.length,
+            p50: round(this.percentile(sorted, 0.5)),
+            p95: round(this.percentile(sorted, 0.95)),
+            max: round(sorted[sorted.length - 1]),
+            mean: round(sum / sorted.length),
+        };
+    }
+    /** Nearest-rank percentile on a pre-sorted ascending array. */
+    percentile(sorted, p) {
+        if (sorted.length === 1)
+            return sorted[0];
+        const rank = Math.ceil(p * sorted.length);
+        const idx = Math.max(0, Math.min(rank - 1, sorted.length - 1));
+        return sorted[idx];
+    }
+}
+/** Singleton shared across the process. */
+export const metrics = new Metrics();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucu-mcp",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "MCP server for Universal Computer Use — desktop automation for AI agents via Model Context Protocol",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/2876674942/ucu-mcp-backup.git"
+    "url": "git+https://github.com/kaguyaluna2333/ucu-mcp-backup.git"
   },
   "license": "MIT",
   "dependencies": {