Merge pull request 'dev/2026-04-08' (#1) from dev/2026-04-08 into main

Reviewed-on: #1

package-lock.json

@@ -12,14 +12,10 @@
       },
       "devDependencies": {
         "@types/node": "^25.5.2",
-        "openclaw": "file:/usr/lib/node_modules/openclaw",
         "typescript": "^5.6.3",
         "vitest": "^4.1.3"
       }
     },
-    "../../../../../usr/lib/node_modules/openclaw": {
-      "dev": true
-    },
     "node_modules/@emnapi/core": {
       "version": "1.9.1",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.1.tgz",
@@ -918,10 +914,6 @@
       ],
       "license": "MIT"
     },
-    "node_modules/openclaw": {
-      "resolved": "../../../../../usr/lib/node_modules/openclaw",
-      "link": true
-    },
     "node_modules/pathe": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",

package.json

@@ -32,7 +32,6 @@
   "devDependencies": {
     "@types/node": "^25.5.2",
     "typescript": "^5.6.3",
-    "vitest": "^4.1.3",
+    "vitest": "^4.1.3"
-    "openclaw": "file:/usr/lib/node_modules/openclaw"
   }
 }

plugin/core/config.ts

@@ -1,22 +1,7 @@
-export type NotifyProvider = "discord" | "fabric";
-
-export interface FabricNotifyConfig {
-  centerApiBase: string;
-  apiKey: string;
-  guildNodeId: string;
-  channelId: string;
-}
-
 export interface YonexusServerConfig {
   followerIdentifiers: string[];
-  /** Pairing-code delivery provider. Default: "discord" (back-compat). */
+  notifyBotToken: string;
-  notifyProvider: NotifyProvider;
+  adminUserId: string;
-  /** Required only when notifyProvider === "discord". */
-  notifyBotToken?: string;
-  /** Required only when notifyProvider === "discord". */
-  adminUserId?: string;
-  /** Required only when notifyProvider === "fabric". */
-  fabric?: FabricNotifyConfig;
   listenHost?: string;
   listenPort: number;
   publicWsUrl?: string;
@@ -74,53 +59,22 @@ export function validateYonexusServerConfig(raw: unknown): YonexusServerConfig {
         .filter((value) => value.length > 0)
     : [];
 
-  if (!Array.isArray(rawIdentifiers)) {
+  if (!Array.isArray(rawIdentifiers) || followerIdentifiers.length === 0) {
-    issues.push("followerIdentifiers must be an array");
+    issues.push("followerIdentifiers must contain at least one non-empty identifier");
   }
 
   if (new Set(followerIdentifiers).size !== followerIdentifiers.length) {
     issues.push("followerIdentifiers must not contain duplicates");
   }
 
-  const rawNotifyProvider = source.notifyProvider;
-  let notifyProvider: NotifyProvider = "discord";
-  if (rawNotifyProvider === undefined || rawNotifyProvider === null) {
-    notifyProvider = "discord";
-  } else if (rawNotifyProvider === "discord" || rawNotifyProvider === "fabric") {
-    notifyProvider = rawNotifyProvider;
-  } else {
-    issues.push('notifyProvider must be "discord" or "fabric"');
-  }
-
-  // Discord fields — required only for the discord provider.
   const rawNotifyBotToken = source.notifyBotToken;
-  const rawAdminUserId = source.adminUserId;
+  if (!isNonEmptyString(rawNotifyBotToken)) {
-  if (notifyProvider === "discord") {
+    issues.push("notifyBotToken is required");
-    if (!isNonEmptyString(rawNotifyBotToken)) {
-      issues.push('notifyBotToken is required when notifyProvider is "discord"');
-    }
-    if (!isNonEmptyString(rawAdminUserId)) {
-      issues.push('adminUserId is required when notifyProvider is "discord"');
-    }
   }
 
-  // Fabric fields — required only for the fabric provider.
+  const rawAdminUserId = source.adminUserId;
-  let fabric: FabricNotifyConfig | undefined;
+  if (!isNonEmptyString(rawAdminUserId)) {
-  if (notifyProvider === "fabric") {
+    issues.push("adminUserId is required");
-    const f = (source.fabric && typeof source.fabric === "object"
-      ? source.fabric
-      : {}) as Record<string, unknown>;
-    const centerApiBase = normalizeOptionalString(f.centerApiBase);
-    const apiKey = normalizeOptionalString(f.apiKey);
-    const guildNodeId = normalizeOptionalString(f.guildNodeId);
-    const channelId = normalizeOptionalString(f.channelId);
-    if (!centerApiBase) issues.push("fabric.centerApiBase is required when notifyProvider is \"fabric\"");
-    if (!apiKey) issues.push("fabric.apiKey is required when notifyProvider is \"fabric\"");
-    if (!guildNodeId) issues.push("fabric.guildNodeId is required when notifyProvider is \"fabric\"");
-    if (!channelId) issues.push("fabric.channelId is required when notifyProvider is \"fabric\"");
-    if (centerApiBase && apiKey && guildNodeId && channelId) {
-      fabric = { centerApiBase, apiKey, guildNodeId, channelId };
-    }
   }
 
   const rawListenPort = source.listenPort;
@@ -139,18 +93,14 @@ export function validateYonexusServerConfig(raw: unknown): YonexusServerConfig {
     throw new YonexusServerConfigError(issues);
   }
 
+  const notifyBotToken = rawNotifyBotToken as string;
+  const adminUserId = rawAdminUserId as string;
   const listenPort = rawListenPort as number;
 
   return {
     followerIdentifiers,
-    notifyProvider,
+    notifyBotToken: notifyBotToken.trim(),
-    notifyBotToken: isNonEmptyString(rawNotifyBotToken)
+    adminUserId: adminUserId.trim(),
-      ? rawNotifyBotToken.trim()
-      : undefined,
-    adminUserId: isNonEmptyString(rawAdminUserId)
-      ? rawAdminUserId.trim()
-      : undefined,
-    fabric,
     listenHost,
     listenPort,
     publicWsUrl

plugin/core/runtime.ts

@@ -38,12 +38,14 @@ import {
   type ClientRecord,
   type ServerRegistry
 } from "./persistence.js";
-import { verifySignature } from "../../../Yonexus.Protocol/src/crypto.js";
+import { verifySignature } from "../../../Yonexus.Client/plugin/crypto/keypair.js";
 import type { YonexusServerStore } from "./store.js";
 import { type ClientConnection, type ServerTransport } from "./transport.js";
 import { createPairingService, type PairingService } from "../services/pairing.js";
-import type { PairingNotificationService } from "../notifications/types.js";
+import {
-import { createNotificationService } from "../notifications/factory.js";
+  createDiscordNotificationService,
+  type DiscordNotificationService
+} from "../notifications/discord.js";
 import { safeErrorMessage } from "./logging.js";
 import type { ServerRuleRegistry } from "./rules.js";
 
@@ -51,7 +53,7 @@ export interface YonexusServerRuntimeOptions {
   config: YonexusServerConfig;
   store: YonexusServerStore;
   transport: ServerTransport;
-  notificationService?: PairingNotificationService;
+  notificationService?: DiscordNotificationService;
   ruleRegistry?: ServerRuleRegistry;
   onClientAuthenticated?: (identifier: string) => void;
   now?: () => number;
@@ -68,7 +70,7 @@ export class YonexusServerRuntime {
   private readonly now: () => number;
   private readonly registry: ServerRegistry;
   private readonly pairingService: PairingService;
-  private readonly notificationService: PairingNotificationService;
+  private readonly notificationService: DiscordNotificationService;
   private readonly sweepIntervalMs: number;
   private sweepTimer: NodeJS.Timeout | null = null;
   private started = false;
@@ -84,7 +86,10 @@ export class YonexusServerRuntime {
     this.pairingService = createPairingService({ now: this.now });
     this.notificationService =
       options.notificationService ??
-      createNotificationService(options.config);
+      createDiscordNotificationService({
+        botToken: options.config.notifyBotToken,
+        adminUserId: options.config.adminUserId
+      });
   }
 
   get state(): ServerLifecycleState {

plugin/index.ts

@@ -32,9 +32,6 @@ export {
 
 import path from "node:path";
 import fs from "node:fs";
-import os from "node:os";
-import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { validateYonexusServerConfig } from "./core/config.js";
 import { createYonexusServerStore } from "./core/store.js";
 import { createServerTransport, type ServerTransport } from "./core/transport.js";
@@ -43,8 +40,6 @@ import { createServerRuleRegistry, YonexusServerRuleRegistry } from "./core/rule
 import { encodeRuleMessage } from "../../Yonexus.Protocol/src/index.js";
 import type { ServerPersistenceData } from "./core/persistence.js";
 
-const PLUGIN_DATA_DIR = path.join(os.homedir(), ".openclaw", "yonexus-server");
-
 const _G = globalThis as Record<string, unknown>;
 const _STARTED_KEY   = "_yonexusServerStarted";
 const _TRANSPORT_KEY = "_yonexusServerTransport";
@@ -63,8 +58,14 @@ const manifest: YonexusServerPluginManifest = {
   description: "Yonexus central hub plugin for cross-instance OpenClaw communication"
 };
 
-export function createYonexusServerPlugin(api: OpenClawPluginApi): void {
+export function createYonexusServerPlugin(api: {
-  const stateFilePath = path.join(PLUGIN_DATA_DIR, "state.json");
+  rootDir: string;
+  pluginConfig: unknown;
+  registrationMode?: string;  // "full" (gateway) | "cli-metadata" | "setup-only" | "setup-runtime"
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  registerCli?: (registrar: (ctx: { program: any }) => void, opts?: { commands?: string[] }) => void;
+}): void {
+  const stateFilePath = path.join(api.rootDir, "state.json");
 
   // Register CLI regardless of whether the gateway is already running.
   // The CLI process is a separate invocation that reads from the persisted state file.
@@ -161,72 +162,60 @@ export function createYonexusServerPlugin(api: OpenClawPluginApi): void {
     onClientAuthenticated: onClientAuthenticatedCallbacks
   };
 
-  // 3. Runtime startup — only fire when the gateway boots, not eagerly during
+  // 3. Start the runtime only once — the globalThis flag survives hot-reload
-  //    register() inside one-shot CLI subprocesses (e.g. `openclaw completion`).
+  if (_G[_STARTED_KEY]) return;
-  //    Without this gate, every CLI invocation that loads plugins would try to
+  _G[_STARTED_KEY] = true;
-  //    bind the WebSocket listener; EADDRINUSE recovery handled the gateway-
-  //    already-running case but a genuine first-bind in a subprocess would
-  //    keep that process alive forever.
-  api.on("gateway_start", () => {
-    if (_G[_STARTED_KEY]) return;
-    _G[_STARTED_KEY] = true;
 
-    fs.mkdirSync(PLUGIN_DATA_DIR, { recursive: true });
+  const config = validateYonexusServerConfig(api.pluginConfig);
+  const store = createYonexusServerStore(stateFilePath);
 
-    const config = validateYonexusServerConfig(api.pluginConfig);
+  // runtimeRef is local; transport is stored in globalThis so sendRule closures stay valid
-    const store = createYonexusServerStore(stateFilePath);
+  let runtimeRef: ReturnType<typeof createYonexusServerRuntime> | null = null;
-
+  const transport = createServerTransport({
-    // runtimeRef is local; transport is stored in globalThis so sendRule closures stay valid
+    config,
-    let runtimeRef: ReturnType<typeof createYonexusServerRuntime> | null = null;
+    onMessage: (conn, msg) => {
-    const transport = createServerTransport({
+      runtimeRef?.handleMessage(conn, msg).catch((err: unknown) => {
-      config,
+        console.error("[yonexus-server] message handler error:", err);
-      onMessage: (conn, msg) => {
+      });
-        runtimeRef?.handleMessage(conn, msg).catch((err: unknown) => {
+    },
-          console.error("[yonexus-server] message handler error:", err);
+    onDisconnect: (identifier) => {
-        });
+      if (identifier && runtimeRef) {
-      },
+        runtimeRef.handleDisconnect(identifier);
-      onDisconnect: (identifier) => {
-        if (identifier && runtimeRef) {
-          runtimeRef.handleDisconnect(identifier);
-        }
       }
-    });
+    }
-    _G[_TRANSPORT_KEY] = transport;
-
-    const runtime = createYonexusServerRuntime({
-      config,
-      store,
-      transport,
-      ruleRegistry,
-      onClientAuthenticated: (identifier) => {
-        for (const cb of onClientAuthenticatedCallbacks) cb(identifier);
-      }
-    });
-    runtimeRef = runtime;
-    _G["_yonexusServerRuntime"] = runtime;
-
-    runtime.start().catch((err: unknown) => {
-      const code = (err as NodeJS.ErrnoException | undefined)?.code;
-      if (code !== "EADDRINUSE") {
-        console.error("[yonexus-server] failed to start:", err);
-      }
-    });
   });
+  _G[_TRANSPORT_KEY] = transport;
 
-  api.on("gateway_stop", () => {
+  const runtime = createYonexusServerRuntime({
-    const runtime = _G["_yonexusServerRuntime"] as ReturnType<typeof createYonexusServerRuntime> | undefined;
+    config,
-    runtime?.stop().catch((err: unknown) => {
+    store,
+    transport,
+    ruleRegistry,
+    onClientAuthenticated: (identifier) => {
+      for (const cb of onClientAuthenticatedCallbacks) cb(identifier);
+    }
+  });
+  runtimeRef = runtime;
+
+  const shutdown = (): void => {
+    runtime.stop().catch((err: unknown) => {
       console.error("[yonexus-server] shutdown error:", err);
     });
+  };
+  process.once("SIGTERM", shutdown);
+  process.once("SIGINT", shutdown);
+
+  runtime.start().catch((err: unknown) => {
+    // EADDRINUSE means the gateway is already running (e.g. this is a CLI invocation).
+    // Any other error is a real problem worth logging.
+    const code = (err as NodeJS.ErrnoException | undefined)?.code;
+    if (code !== "EADDRINUSE") {
+      console.error("[yonexus-server] failed to start:", err);
+    }
   });
 }
 
-export default definePluginEntry({
+export default createYonexusServerPlugin;
-  id: "yonexus-server",
-  name: "Yonexus.Server",
-  description: "Yonexus central hub plugin for cross-instance OpenClaw communication",
-  register: createYonexusServerPlugin,
-});
 export {
   createServerTransport,
   YonexusServerTransport,
@@ -265,11 +254,5 @@ export {
   type DiscordNotificationService,
   type DiscordNotificationConfig
 } from "./notifications/discord.js";
-export type { PairingNotificationService } from "./notifications/types.js";
-export {
-  createFabricNotificationService,
-  type FabricNotificationConfig
-} from "./notifications/fabric.js";
-export { createNotificationService } from "./notifications/factory.js";
 
 export { manifest };

plugin/notifications/discord.ts

@@ -5,14 +5,15 @@
  */
 
 import type { PairingRequest } from "../services/pairing.js";
-import type { PairingNotificationService } from "./types.js";
 import { redactPairingCode, safeErrorMessage } from "../core/logging.js";
 
-/**
+export interface DiscordNotificationService {
- * Back-compat alias. The Discord notifier is one provider implementing
+  /**
- * the neutral {@link PairingNotificationService} contract.
+   * Send a pairing code notification to the admin user.
- */
+   * @returns Whether the notification was sent successfully
-export type DiscordNotificationService = PairingNotificationService;
+   */
+  sendPairingNotification(request: PairingRequest): Promise<boolean>;
+}
 
 export interface DiscordNotificationConfig {
   botToken: string;

plugin/notifications/fabric.ts

@@ -1,156 +0,0 @@
-/**
- * Yonexus Server - Fabric Notification Service
- *
- * Sends pairing notifications to a human admin via a Fabric channel.
- *
- * Flow:
- * 1. Exchange the Center API key for a user session
- *    (POST {centerApiBase}/auth/agent/login → user + guild tokens)
- * 2. Resolve the target guild's endpoint + access token by guildNodeId
- * 3. POST the formatted pairing message to the configured channel
- *    ({guildEndpoint}/api/channels/{channelId}/messages)
- *
- * Self-contained (global fetch) and dependency-free, mirroring the
- * Discord notifier; it does not import the Fabric.OpenclawPlugin.
- */
-
-import type { PairingRequest } from "../services/pairing.js";
-import type { PairingNotificationService } from "./types.js";
-import { formatPairingMessage } from "./discord.js";
-import { redactPairingCode, safeErrorMessage } from "../core/logging.js";
-
-export interface FabricNotificationConfig {
-  /** Fabric Center API base, e.g. http://localhost:7001/api */
-  centerApiBase: string;
-  /** Fabric Center API key (fak_…) for the notifier identity */
-  apiKey: string;
-  /** Target guild node id the admin channel lives on */
-  guildNodeId: string;
-  /** Channel id (a Fabric channel the admin watches) */
-  channelId: string;
-}
-
-interface FabricSession {
-  user: { id: string };
-  guilds: Array<{ nodeId: string; endpoint: string }>;
-  guildAccessTokens: Array<{ guildNodeId: string; token: string }>;
-}
-
-export interface FabricApiResponse {
-  ok: boolean;
-  status: number;
-  json(): Promise<unknown>;
-}
-
-export type FabricFetch = (
-  input: string,
-  init?: { method?: string; headers?: Record<string, string>; body?: string }
-) => Promise<FabricApiResponse>;
-
-/**
- * Create a Fabric notification service backed by the Fabric Center +
- * Guild REST API.
- */
-export function createFabricNotificationService(
-  config: FabricNotificationConfig,
-  options: { fetcher?: FabricFetch } = {}
-): PairingNotificationService {
-  const fetcher = options.fetcher ?? getDefaultFetch();
-
-  return {
-    async sendPairingNotification(request: PairingRequest): Promise<boolean> {
-      if (
-        !config.centerApiBase.trim() ||
-        !config.apiKey.trim() ||
-        !config.guildNodeId.trim() ||
-        !config.channelId.trim()
-      ) {
-        console.error("[Yonexus.Server] Fabric notification misconfigured", {
-          hasCenterApiBase: Boolean(config.centerApiBase.trim()),
-          hasApiKey: Boolean(config.apiKey.trim()),
-          hasGuildNodeId: Boolean(config.guildNodeId.trim()),
-          hasChannelId: Boolean(config.channelId.trim())
-        });
-        return false;
-      }
-
-      try {
-        const base = config.centerApiBase.replace(/\/+$/, "");
-        const loginRes = await fetcher(`${base}/auth/agent/login`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ apiKey: config.apiKey })
-        });
-        if (!loginRes.ok) {
-          throw new Error(`agent/login failed with status ${loginRes.status}`);
-        }
-        const session = (await loginRes.json()) as FabricSession;
-
-        const endpoint = session.guilds
-          .find((g) => g.nodeId === config.guildNodeId)
-          ?.endpoint?.replace(/\/+$/, "");
-        const token = session.guildAccessTokens.find(
-          (t) => t.guildNodeId === config.guildNodeId
-        )?.token;
-        if (!endpoint || !token) {
-          throw new Error(
-            `notifier identity is not a member of guild ${config.guildNodeId}`
-          );
-        }
-
-        const msgRes = await fetcher(
-          `${endpoint}/api/channels/${config.channelId}/messages`,
-          {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              content: formatPairingMessage(request),
-              authorUserId: session.user.id
-            })
-          }
-        );
-        if (!msgRes.ok) {
-          throw new Error(`message post failed with status ${msgRes.status}`);
-        }
-        await msgRes.json();
-
-        console.log("[Yonexus.Server] Pairing notification sent via Fabric", {
-          identifier: request.identifier,
-          pairingCode: redactPairingCode(request.pairingCode),
-          expiresAt: request.expiresAt,
-          ttlSeconds: request.ttlSeconds,
-          guildNodeId: config.guildNodeId,
-          channelId: config.channelId
-        });
-        return true;
-      } catch (error) {
-        console.error(
-          "[Yonexus.Server] Failed to send Fabric pairing notification",
-          {
-            identifier: request.identifier,
-            pairingCode: redactPairingCode(request.pairingCode),
-            guildNodeId: config.guildNodeId,
-            channelId: config.channelId,
-            error: safeErrorMessage(error)
-          }
-        );
-        return false;
-      }
-    }
-  };
-}
-
-function getDefaultFetch(): FabricFetch {
-  if (typeof fetch !== "function") {
-    throw new Error("Global fetch is not available in this runtime");
-  }
-  return (input, init) =>
-    fetch(input, {
-      method: init?.method,
-      headers: init?.headers,
-      body: init?.body
-    }) as Promise<FabricApiResponse>;
-}

plugin/notifications/factory.ts

@@ -1,30 +0,0 @@
-/**
- * Yonexus Server - Pairing notification provider factory.
- *
- * Selects the notification provider from config (`notifyProvider`).
- * Discord is the default for backward compatibility.
- */
-
-import type { YonexusServerConfig } from "../core/config.js";
-import type { PairingNotificationService } from "./types.js";
-import { createDiscordNotificationService } from "./discord.js";
-import { createFabricNotificationService } from "./fabric.js";
-
-export function createNotificationService(
-  config: YonexusServerConfig
-): PairingNotificationService {
-  if (config.notifyProvider === "fabric") {
-    if (!config.fabric) {
-      throw new Error(
-        'Yonexus.Server: notifyProvider is "fabric" but fabric config is missing'
-      );
-    }
-    return createFabricNotificationService(config.fabric);
-  }
-
-  // Default / "discord"
-  return createDiscordNotificationService({
-    botToken: config.notifyBotToken ?? "",
-    adminUserId: config.adminUserId ?? ""
-  });
-}

plugin/notifications/types.ts

@@ -1,18 +0,0 @@
-/**
- * Yonexus Server - Pairing notification provider interface.
- *
- * A provider delivers the out-of-band pairing code to a human admin.
- * Implementations: Discord DM (`./discord.ts`), Fabric channel
- * (`./fabric.ts`). The provider is selected by config (see
- * `core/config.ts` `notifyProvider`).
- */
-
-import type { PairingRequest } from "../services/pairing.js";
-
-export interface PairingNotificationService {
-  /**
-   * Send a pairing code notification to the admin.
-   * @returns Whether the notification was sent successfully.
-   */
-  sendPairingNotification(request: PairingRequest): Promise<boolean>;
-}

plugin/openclaw.plugin.json

@@ -1,13 +1,10 @@
 {
   "id": "yonexus-server",
   "name": "Yonexus.Server",
+  "version": "0.1.0",
   "description": "Yonexus central hub plugin for cross-instance OpenClaw communication",
-  "activation": {
+  "entry": "./dist/Yonexus.Server/plugin/index.js",
-    "onStartup": true
+  "permissions": [],
-  },
-  "commandAliases": [
-    { "name": "yonexus-server" }
-  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -16,24 +13,12 @@
         "type": "array",
         "items": { "type": "string" }
       },
-      "notifyProvider": { "type": "string", "enum": ["discord", "fabric"] },
       "notifyBotToken": { "type": "string" },
       "adminUserId": { "type": "string" },
-      "fabric": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "centerApiBase": { "type": "string" },
-          "apiKey": { "type": "string" },
-          "guildNodeId": { "type": "string" },
-          "channelId": { "type": "string" }
-        },
-        "required": ["centerApiBase", "apiKey", "guildNodeId", "channelId"]
-      },
       "listenHost": { "type": "string" },
       "listenPort": { "type": "number" },
       "publicWsUrl": { "type": "string" }
     },
-    "required": ["listenPort"]
+    "required": ["followerIdentifiers", "notifyBotToken", "adminUserId", "listenPort"]
   }
 }

scripts/install.mjs

@@ -3,7 +3,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { execSync } from "node:child_process";
 
 const args = process.argv.slice(2);
 const mode = args.includes("--install") ? "install" : args.includes("--uninstall") ? "uninstall" : null;
@@ -16,42 +15,9 @@ if (!mode) {
 }
 
 const repoRoot = path.resolve(import.meta.dirname, "..");
-const pluginId = "yonexus-server";
+const pluginName = "Yonexus.Server";
 const sourceDist = path.join(repoRoot, "dist");
-const targetDir = path.join(profilePath, "plugins", pluginId);
+const targetDir = path.join(profilePath, "plugins", pluginName);
-
-function oc(cmd) {
-  try {
-    return execSync(`openclaw ${cmd}`, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-  } catch (e) {
-    console.error(`  ⚠ openclaw ${cmd}: ${e.stderr?.trim() || e.message}`);
-    return null;
-  }
-}
-
-function ensureInArray(configKey, value) {
-  const raw = oc(`config get ${configKey}`);
-  if (!raw) return;
-  const arr = JSON.parse(raw);
-  if (!arr.includes(value)) {
-    arr.push(value);
-    oc(`config set ${configKey} '${JSON.stringify(arr)}' --json`);
-    console.log(`  ✓ ${configKey} includes ${value}`);
-  } else {
-    console.log(`  ✓ ${configKey} already includes ${value}`);
-  }
-}
-
-function removeFromArray(configKey, value) {
-  const raw = oc(`config get ${configKey}`);
-  if (!raw) return;
-  const arr = JSON.parse(raw);
-  const filtered = arr.filter(v => v !== value);
-  if (filtered.length !== arr.length) {
-    oc(`config set ${configKey} '${JSON.stringify(filtered)}' --json`);
-    console.log(`  ✓ Removed ${value} from ${configKey}`);
-  }
-}
 
 if (mode === "install") {
   if (!fs.existsSync(sourceDist)) {
@@ -64,16 +30,9 @@ if (mode === "install") {
   fs.cpSync(sourceDist, path.join(targetDir, "dist"), { recursive: true });
   fs.copyFileSync(path.join(repoRoot, "plugin", "openclaw.plugin.json"), path.join(targetDir, "openclaw.plugin.json"));
   fs.copyFileSync(path.join(repoRoot, "package.json"), path.join(targetDir, "package.json"));
-  console.log(`  ✓ Plugin files → ${targetDir}`);
+  console.log(`Installed ${pluginName} to ${targetDir}`);
-
-  ensureInArray("plugins.load.paths", targetDir);
-  ensureInArray("plugins.allow", pluginId);
-  console.log(`Installed ${pluginId} to ${targetDir}`);
   process.exit(0);
 }
 
-// uninstall
 fs.rmSync(targetDir, { recursive: true, force: true });
-removeFromArray("plugins.load.paths", targetDir);
+console.log(`Removed ${pluginName} from ${targetDir}`);
-removeFromArray("plugins.allow", pluginId);
-console.log(`Removed ${pluginId} from ${targetDir}`);

tests/auth-failures.test.ts

@@ -10,7 +10,7 @@ import { createYonexusServerRuntime } from "../plugin/core/runtime.js";
 import type { ClientRecord } from "../plugin/core/persistence.js";
 import type { YonexusServerStore } from "../plugin/core/store.js";
 import type { ClientConnection, ServerTransport } from "../plugin/core/transport.js";
-import { generateKeyPair, signMessage } from "../../Yonexus.Protocol/src/crypto.js";
+import { generateKeyPair, signMessage } from "../../Yonexus.Client/plugin/crypto/keypair.js";
 
 function createMockSocket() {
   return { close: vi.fn() } as unknown as ClientConnection["ws"];

tests/fabric-notification.test.ts

@@ -1,109 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import {
-  createFabricNotificationService,
-  type FabricFetch
-} from "../plugin/notifications/fabric.js";
-import { validateYonexusServerConfig } from "../plugin/core/config.js";
-
-const request = {
-  identifier: "client-a",
-  pairingCode: "PAIR-1234-CODE",
-  expiresAt: 1_710_000_300,
-  ttlSeconds: 300,
-  createdAt: 1_710_000_000
-};
-
-const fabricConfig = {
-  centerApiBase: "http://center.local/api",
-  apiKey: "fak_test",
-  guildNodeId: "guild-node-1",
-  channelId: "chan-1"
-};
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe("Fabric notification service", () => {
-  it("logs in, resolves the guild token, and posts the pairing message", async () => {
-    const fetcher = vi
-      .fn<FabricFetch>()
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: async () => ({
-          user: { id: "u-1" },
-          guilds: [{ nodeId: "guild-node-1", endpoint: "http://guild.local" }],
-          guildAccessTokens: [{ guildNodeId: "guild-node-1", token: "gtok" }]
-        })
-      })
-      .mockResolvedValueOnce({ ok: true, status: 200, json: async () => ({}) });
-
-    const svc = createFabricNotificationService(fabricConfig, { fetcher });
-    const ok = await svc.sendPairingNotification(request);
-
-    expect(ok).toBe(true);
-    expect(fetcher).toHaveBeenCalledTimes(2);
-    expect(fetcher.mock.calls[0][0]).toBe("http://center.local/api/auth/agent/login");
-    expect(fetcher.mock.calls[1][0]).toBe(
-      "http://guild.local/api/channels/chan-1/messages"
-    );
-    const msgInit = fetcher.mock.calls[1][1]!;
-    expect(msgInit.headers?.Authorization).toBe("Bearer gtok");
-    expect(msgInit.body).toContain("PAIR-1234-CODE");
-  });
-
-  it("returns false when the notifier is not a member of the guild", async () => {
-    const fetcher = vi.fn<FabricFetch>().mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: async () => ({ user: { id: "u-1" }, guilds: [], guildAccessTokens: [] })
-    });
-
-    const svc = createFabricNotificationService(fabricConfig, { fetcher });
-    expect(await svc.sendPairingNotification(request)).toBe(false);
-  });
-
-  it("returns false when config is incomplete", async () => {
-    const fetcher = vi.fn<FabricFetch>();
-    const svc = createFabricNotificationService(
-      { ...fabricConfig, apiKey: "" },
-      { fetcher }
-    );
-    expect(await svc.sendPairingNotification(request)).toBe(false);
-    expect(fetcher).not.toHaveBeenCalled();
-  });
-});
-
-describe("notifyProvider config selection", () => {
-  it("defaults to discord and still requires discord fields", () => {
-    expect(() =>
-      validateYonexusServerConfig({ listenPort: 8080 })
-    ).toThrowError(/notifyBotToken is required/);
-  });
-
-  it("does not require discord fields when provider is fabric", () => {
-    const cfg = validateYonexusServerConfig({
-      followerIdentifiers: [],
-      listenPort: 8080,
-      notifyProvider: "fabric",
-      fabric: fabricConfig
-    });
-    expect(cfg.notifyProvider).toBe("fabric");
-    expect(cfg.fabric).toEqual(fabricConfig);
-    expect(cfg.notifyBotToken).toBeUndefined();
-  });
-
-  it("requires fabric fields when provider is fabric", () => {
-    expect(() =>
-      validateYonexusServerConfig({ listenPort: 8080, notifyProvider: "fabric" })
-    ).toThrowError(/fabric\.centerApiBase is required/);
-  });
-
-  it("rejects an unknown provider", () => {
-    expect(() =>
-      validateYonexusServerConfig({ listenPort: 8080, notifyProvider: "sms" })
-    ).toThrowError(/notifyProvider must be/);
-  });
-});

tests/runtime-flow.test.ts

@@ -17,7 +17,7 @@ import { createYonexusServerRuntime } from "../plugin/core/runtime.js";
 import type { ClientRecord } from "../plugin/core/persistence.js";
 import type { YonexusServerStore } from "../plugin/core/store.js";
 import type { ClientConnection, ServerTransport } from "../plugin/core/transport.js";
-import { generateKeyPair, signMessage, verifySignature } from "../../Yonexus.Protocol/src/crypto.js";
+import { generateKeyPair, signMessage, verifySignature } from "../../Yonexus.Client/plugin/crypto/keypair.js";
 
 function createMockSocket() {
   return {