@johnny-joster/n9e-plugin 1.0.7 → 1.0.9

package/index.ts

@@ -1,19 +1,19 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { createN9eClient } from "./src/n9e-client.js";
+import { createActiveAlertsTool } from "./src/tools/active-alerts.js";
+import { createHistoricalAlertsTool } from "./src/tools/historical-alerts.js";
+import { createAlertRulesTool } from "./src/tools/alert-rules.js";
+import { createAlertMutesTool } from "./src/tools/alert-mutes.js";
 
-export default function(api: OpenClawPluginApi) {
-  api.logger.info("=== N9e plugin: Entry point called ===");
+export default function register(api: OpenClawPluginApi) {
+  api.logger.info("N9e plugin: initializing", { id: api.id });
 
-  try {
-    api.logger.info("=== N9e plugin: Starting initialization ===");
+  const client = createN9eClient(api.config);
 
-    // 不注册任何工具，只是测试插件能否加载
-    api.logger.info("=== N9e plugin: Skipping tool registration (test mode) ===");
+  api.registerTool(createActiveAlertsTool(client));
+  api.registerTool(createHistoricalAlertsTool(client));
+  api.registerTool(createAlertRulesTool(client));
+  api.registerTool(createAlertMutesTool(client));
 
-    api.logger.info("=== N9e plugin: Initialization completed successfully ===");
-  } catch (error) {
-    api.logger.error("=== N9e plugin: Failed to load ===", error);
-    throw error;
-  }
-
-  api.logger.info("=== N9e plugin: Function exit ===");
+  api.logger.info("N9e plugin: registered 4 tools");
 }

package/openclaw.plugin.json

@@ -1,7 +1,11 @@
 {
   "id": "n9e-plugin",
+  "name": "Nightingale Alert Plugin",
+  "version": "1.0.0",
+  "description": "夜莺告警平台查询插件，支持活跃告警、历史告警、告警规则、告警屏蔽查询",
   "configSchema": {
     "type": "object",
+    "additionalProperties": false,
     "properties": {
       "apiBaseUrl": {
         "type": "string",
@@ -18,6 +22,20 @@
         "default": 30000,
         "description": "请求超时时间(毫秒)"
       }
+    },
+    "required": ["apiBaseUrl", "apiKey"]
+  },
+  "uiHints": {
+    "apiBaseUrl": {
+      "label": "API 地址",
+      "placeholder": "http://n9e.example.com"
+    },
+    "apiKey": {
+      "label": "API Key",
+      "sensitive": true
+    },
+    "timeout": {
+      "label": "请求超时 (ms)"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnny-joster/n9e-plugin",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Nightingale alert platform query plugin for OpenClaw",
   "type": "module",
   "main": "index.ts",
@@ -14,6 +14,9 @@
   "keywords": ["openclaw", "plugin", "nightingale", "n9e", "alerts"],
   "author": "Youdao",
   "license": "MIT",
+  "dependencies": {
+    "@sinclair/typebox": "^0.32.0"
+  },
   "devDependencies": {
     "@types/node": "^20.11.0",
     "typescript": "^5.3.3"

package/src/n9e-client.ts

@@ -0,0 +1,105 @@
+import type { PluginConfig } from "openclaw/plugin-sdk";
+import type { AlertCurEvent, AlertHisEvent, AlertRule, AlertMute, ListResponse } from "./types.js";
+
+interface N9eConfig {
+  apiBaseUrl: string;
+  apiKey: string;
+  timeout?: number;
+}
+
+export interface ActiveAlertsParams {
+  severity?: number;
+  query?: string;
+  hours?: number;
+  limit?: number;
+}
+
+export interface HistoricalAlertsParams {
+  severity?: number;
+  query?: string;
+  hours?: number;
+  is_recovered?: number;
+  limit?: number;
+}
+
+export interface AlertRulesParams {
+  query?: string;
+  group_id?: number;
+  disabled?: number;
+  limit?: number;
+}
+
+export interface AlertMutesParams {
+  group_id: number;
+  query?: string;
+}
+
+export function createN9eClient(config: PluginConfig) {
+  const { apiBaseUrl, apiKey, timeout = 30000 } = config as unknown as N9eConfig;
+
+  async function request<T>(path: string, params: Record<string, unknown> = {}): Promise<T> {
+    const url = new URL(`${apiBaseUrl}${path}`);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== undefined && value !== null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await fetch(url.toString(), {
+        headers: { "X-API-Key": apiKey },
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      return response.json() as Promise<T>;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  return {
+    async getActiveAlerts(params: ActiveAlertsParams): Promise<ListResponse<AlertCurEvent>> {
+      return request<ListResponse<AlertCurEvent>>("/api/n9e/alert-cur-events/list", {
+        severity: params.severity,
+        query: params.query,
+        hours: params.hours,
+        limit: params.limit ?? 20,
+      });
+    },
+
+    async getHistoricalAlerts(params: HistoricalAlertsParams): Promise<ListResponse<AlertHisEvent>> {
+      return request<ListResponse<AlertHisEvent>>("/api/n9e/alert-his-events/list", {
+        severity: params.severity,
+        query: params.query,
+        hours: params.hours,
+        is_recovered: params.is_recovered,
+        limit: params.limit ?? 20,
+      });
+    },
+
+    async getAlertRules(params: AlertRulesParams): Promise<ListResponse<AlertRule>> {
+      return request<ListResponse<AlertRule>>("/api/n9e/alert-rules", {
+        query: params.query,
+        group_id: params.group_id,
+        disabled: params.disabled,
+        limit: params.limit ?? 20,
+      });
+    },
+
+    async getAlertMutes(params: AlertMutesParams): Promise<AlertMute[]> {
+      return request<AlertMute[]>(
+        `/api/n9e/busi-group/${params.group_id}/alert-mutes/search-by-query`,
+        { query: params.query }
+      );
+    },
+  };
+}
+
+export type N9eClient = ReturnType<typeof createN9eClient>;

package/src/openclaw-plugin-sdk.d.ts

@@ -1,47 +1,58 @@
-// Type declarations for openclaw/plugin-sdk
-declare module "openclaw/plugin-sdk" {
-  export interface ToolHandler {
-    (input: any, context: ToolContext): Promise<ToolResult>;
-  }
-
-  export interface ToolContext {
-    config: {
-      plugins?: {
-        entries?: {
-          [key: string]: {
-            config?: any;
-          };
-        };
-      };
-    };
-    logger: {
-      info: (...args: any[]) => void;
-      error: (...args: any[]) => void;
-      warn: (...args: any[]) => void;
-      debug: (...args: any[]) => void;
-    };
-  }
-
-  export interface ToolResult {
-    content: Array<{
-      type: string;
-      text: string;
-    }>;
-    isError?: boolean;
-  }
-
-  export interface OpenClawPluginApi {
-    registerTool: (tool: {
-      name: string;
-      description: string;
-      inputSchema: any;
-      handler: ToolHandler;
-    }) => void;
-    logger: {
-      info: (...args: any[]) => void;
-      error: (...args: any[]) => void;
-      warn: (...args: any[]) => void;
-      debug: (...args: any[]) => void;
-    };
-  }
+import type { TSchema } from "@sinclair/typebox";
+
+export interface ToolResult {
+  type: "text" | "json" | "error" | "image";
+  content: string;
+  data?: Record<string, unknown>;
+  done?: boolean;
+}
+
+export interface ToolContext {
+  sessionKey: string;
+  channel: string;
+  senderId: string;
+  config: Record<string, unknown>;
+  deps: Record<string, unknown>;
+}
+
+export interface ToolExecuteParams {
+  args: Record<string, unknown>;
+  context: ToolContext;
+}
+
+export type ToolExecuteFunction = (
+  params: ToolExecuteParams
+) => Promise<ToolResult> | AsyncIterable<ToolResult>;
+
+export interface AgentTool {
+  name: string;
+  description: string;
+  parameters: TSchema;
+  execute: ToolExecuteFunction;
+}
+
+export interface PluginConfig {
+  [key: string]: unknown;
+}
+
+export interface Logger {
+  info: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+}
+
+export interface OpenClawPluginApi {
+  id: string;
+  config: PluginConfig;
+  logger: Logger;
+  runtime: Record<string, unknown>;
+  registerTool(tool: AgentTool): void;
+  registerChannel(options: { plugin: unknown }): void;
+  registerGatewayMethod(method: string, handler: unknown): void;
+  registerHttpRoute(path: string, handler: unknown): void;
+  registerCli(registerFn: unknown, metadata: unknown): void;
+  registerService(service: unknown): void;
+  registerCommand(command: unknown): void;
+  registerProvider(provider: unknown): void;
 }

package/src/tools/active-alerts.ts

@@ -0,0 +1,46 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "openclaw/plugin-sdk";
+import type { N9eClient } from "../n9e-client.js";
+
+export function createActiveAlertsTool(client: N9eClient): AgentTool {
+  return {
+    name: "n9e_query_active_alerts",
+    description: `查询夜莺平台当前活跃的告警事件。
+当用户询问当前有哪些告警、活跃告警状态、正在触发的告警时使用。
+返回告警列表，包含规则名称、告警级别、触发时间、触发值等信息。`,
+    parameters: Type.Object({
+      severity: Type.Optional(Type.Number({
+        description: "告警级别筛选：1-紧急 2-警告 3-通知，不传则返回全部",
+      })),
+      query: Type.Optional(Type.String({
+        description: "关键词搜索，支持规则名称、标签模糊搜索",
+      })),
+      hours: Type.Optional(Type.Number({
+        description: "查询最近N小时的告警，不传则返回所有活跃告警",
+      })),
+      limit: Type.Optional(Type.Number({
+        description: "返回数量限制，默认20",
+        default: 20,
+      })),
+    }),
+    execute: async ({ args }) => {
+      try {
+        const data = await client.getActiveAlerts({
+          severity: args.severity as number | undefined,
+          query: args.query as string | undefined,
+          hours: args.hours as number | undefined,
+          limit: args.limit as number | undefined,
+        });
+        return {
+          type: "json",
+          content: JSON.stringify(data, null, 2),
+        };
+      } catch (error) {
+        return {
+          type: "error",
+          content: `查询活跃告警失败: ${error instanceof Error ? error.message : "未知错误"}`,
+        };
+      }
+    },
+  };
+}

package/src/tools/alert-mutes.ts

@@ -0,0 +1,37 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "openclaw/plugin-sdk";
+import type { N9eClient } from "../n9e-client.js";
+
+export function createAlertMutesTool(client: N9eClient): AgentTool {
+  return {
+    name: "n9e_query_alert_mutes",
+    description: `查询夜莺平台的告警屏蔽规则。
+当用户询问告警屏蔽、屏蔽规则、哪些告警被静默时使用。
+返回屏蔽规则列表，包含屏蔽原因、生效时间范围等信息。`,
+    parameters: Type.Object({
+      group_id: Type.Number({
+        description: "业务组ID（必填）",
+      }),
+      query: Type.Optional(Type.String({
+        description: "搜索关键字",
+      })),
+    }),
+    execute: async ({ args }) => {
+      try {
+        const data = await client.getAlertMutes({
+          group_id: args.group_id as number,
+          query: args.query as string | undefined,
+        });
+        return {
+          type: "json",
+          content: JSON.stringify(data, null, 2),
+        };
+      } catch (error) {
+        return {
+          type: "error",
+          content: `查询告警屏蔽规则失败: ${error instanceof Error ? error.message : "未知错误"}`,
+        };
+      }
+    },
+  };
+}

package/src/tools/alert-rules.ts

@@ -0,0 +1,46 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "openclaw/plugin-sdk";
+import type { N9eClient } from "../n9e-client.js";
+
+export function createAlertRulesTool(client: N9eClient): AgentTool {
+  return {
+    name: "n9e_query_alert_rules",
+    description: `查询夜莺平台的告警规则配置。
+当用户询问告警规则、规则配置、哪些规则在生效时使用。
+返回规则列表，包含规则名称、PromQL、告警级别、生效时间等配置信息。`,
+    parameters: Type.Object({
+      query: Type.Optional(Type.String({
+        description: "搜索关键字，支持规则名称模糊搜索",
+      })),
+      group_id: Type.Optional(Type.Number({
+        description: "业务组ID，不传则查询全部业务组",
+      })),
+      disabled: Type.Optional(Type.Number({
+        description: "启用状态：0-启用 1-禁用 -1-全部（默认）",
+      })),
+      limit: Type.Optional(Type.Number({
+        description: "返回数量限制，默认20",
+        default: 20,
+      })),
+    }),
+    execute: async ({ args }) => {
+      try {
+        const data = await client.getAlertRules({
+          query: args.query as string | undefined,
+          group_id: args.group_id as number | undefined,
+          disabled: args.disabled as number | undefined,
+          limit: args.limit as number | undefined,
+        });
+        return {
+          type: "json",
+          content: JSON.stringify(data, null, 2),
+        };
+      } catch (error) {
+        return {
+          type: "error",
+          content: `查询告警规则失败: ${error instanceof Error ? error.message : "未知错误"}`,
+        };
+      }
+    },
+  };
+}

package/src/tools/historical-alerts.ts

@@ -0,0 +1,50 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "openclaw/plugin-sdk";
+import type { N9eClient } from "../n9e-client.js";
+
+export function createHistoricalAlertsTool(client: N9eClient): AgentTool {
+  return {
+    name: "n9e_query_historical_alerts",
+    description: `查询夜莺平台历史告警事件记录。
+当用户询问历史告警、过去发生的告警、已恢复的告警时使用。
+返回历史告警列表，包含规则名称、告警级别、触发时间、恢复时间等信息。`,
+    parameters: Type.Object({
+      severity: Type.Optional(Type.Number({
+        description: "告警级别筛选：1-紧急 2-警告 3-通知，不传则返回全部",
+      })),
+      query: Type.Optional(Type.String({
+        description: "关键词搜索，支持规则名称、标签模糊搜索",
+      })),
+      hours: Type.Optional(Type.Number({
+        description: "查询最近N小时的历史告警",
+      })),
+      is_recovered: Type.Optional(Type.Number({
+        description: "恢复状态：0-未恢复 1-已恢复 -1-全部（默认）",
+      })),
+      limit: Type.Optional(Type.Number({
+        description: "返回数量限制，默认20",
+        default: 20,
+      })),
+    }),
+    execute: async ({ args }) => {
+      try {
+        const data = await client.getHistoricalAlerts({
+          severity: args.severity as number | undefined,
+          query: args.query as string | undefined,
+          hours: args.hours as number | undefined,
+          is_recovered: args.is_recovered as number | undefined,
+          limit: args.limit as number | undefined,
+        });
+        return {
+          type: "json",
+          content: JSON.stringify(data, null, 2),
+        };
+      } catch (error) {
+        return {
+          type: "error",
+          content: `查询历史告警失败: ${error instanceof Error ? error.message : "未知错误"}`,
+        };
+      }
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,92 @@
+// 夜莺平台数据类型定义
+
+export interface AlertCurEvent {
+  id: number;
+  hash: string;
+  rule_id: number;
+  rule_name: string;
+  rule_note: string;
+  severity: number;
+  cate: string;
+  cluster: string;
+  datasource_id: number;
+  group_id: number;
+  group_name: string;
+  target_ident: string;
+  target_note: string;
+  trigger_time: number;
+  trigger_value: string;
+  first_trigger_time: number;
+  is_recovered: boolean;
+  tags: string[];
+  annotations: Record<string, string>;
+  runbook_url: string;
+}
+
+export interface AlertHisEvent {
+  id: number;
+  hash: string;
+  rule_id: number;
+  rule_name: string;
+  rule_note: string;
+  severity: number;
+  cate: string;
+  cluster: string;
+  datasource_id: number;
+  group_id: number;
+  group_name: string;
+  target_ident: string;
+  target_note: string;
+  trigger_time: number;
+  trigger_value: string;
+  first_trigger_time: number;
+  recover_time: number;
+  is_recovered: number;
+  tags: string[];
+  annotations: Record<string, string>;
+  runbook_url: string;
+}
+
+export interface AlertRule {
+  id: number;
+  name: string;
+  note: string;
+  group_id: number;
+  prod: string;
+  cate: string;
+  severity: number;
+  disabled: number;
+  prom_ql: string;
+  prom_eval_interval: number;
+  prom_for_duration: number;
+  enable_stime: string;
+  enable_etime: string;
+  runbook_url: string;
+  create_at: number;
+  create_by: string;
+  update_at: number;
+  update_by: string;
+}
+
+export interface AlertMute {
+  id: number;
+  group_id: number;
+  prod: string;
+  cate: string;
+  cluster: string;
+  note: string;
+  cause: string;
+  btime: number;
+  etime: number;
+  disabled: number;
+  mute_time_type: number;
+  create_at: number;
+  create_by: string;
+  update_at: number;
+  update_by: string;
+}
+
+export interface ListResponse<T> {
+  list: T[];
+  total: number;
+}

package/tsconfig.json

@@ -3,6 +3,9 @@
     "target": "ES2022",
     "module": "ESNext",
     "moduleResolution": "bundler",
+    "paths": {
+      "openclaw/plugin-sdk": ["./src/openclaw-plugin-sdk.d.ts"]
+    },
     "esModuleInterop": true,
     "strict": true,
     "skipLibCheck": true,

package/.claude/settings.local.json

@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npx tsc:*)",
-      "Bash(npm install)",
-      "Bash(export KUBECONFIG=/Users/yaobinze/workarea/youdao/k8s/k8s-prod-maintain1)",
-      "Bash(kubectl get:*)",
-      "Bash(kubectl logs:*)"
-    ]
-  }
-}