@nextclaw/openclaw-compat 0.3.4 → 0.3.6

package/dist/index.js

@@ -1,2510 +0,0 @@
-// src/plugin-sdk/index.ts
-import { resolveBuiltinChannelRuntime } from "@nextclaw/channel-runtime";
-function emptyPluginConfigSchema() {
-  return {
-    type: "object",
-    additionalProperties: false,
-    properties: {}
-  };
-}
-function buildChannelConfigSchema(schema) {
-  return schema;
-}
-function buildOauthProviderAuthResult(params) {
-  const profileId = params.email ? `${params.providerId}:${params.email}` : params.providerId;
-  return {
-    profiles: [
-      {
-        profileId,
-        credential: {
-          providerId: params.providerId,
-          accessToken: params.access,
-          refreshToken: params.refresh,
-          expiresAt: params.expires,
-          email: params.email,
-          extra: params.credentialExtra ?? {}
-        }
-      }
-    ],
-    defaultModel: params.defaultModel,
-    notes: params.notes
-  };
-}
-async function sleep(ms) {
-  await new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
-}
-function normalizePluginHttpPath(rawPath) {
-  const trimmed = rawPath.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-}
-var DEFAULT_ACCOUNT_ID = "default";
-function normalizeAccountId(accountId) {
-  const trimmed = accountId?.trim();
-  return trimmed || DEFAULT_ACCOUNT_ID;
-}
-function createNextclawBuiltinChannelPlugin(channelId) {
-  const runtime = resolveBuiltinChannelRuntime(channelId);
-  return {
-    id: channelId,
-    nextclaw: {
-      isEnabled: runtime.isEnabled,
-      createChannel: runtime.createChannel
-    }
-  };
-}
-var __nextclawPluginSdkCompat = true;
-
-// src/plugins/config-state.ts
-function normalizeList(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
-}
-function normalizeEntries(entries) {
-  if (!entries || typeof entries !== "object" || Array.isArray(entries)) {
-    return {};
-  }
-  const normalized = {};
-  for (const [idRaw, value] of Object.entries(entries)) {
-    const id = idRaw.trim();
-    if (!id) {
-      continue;
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      normalized[id] = {};
-      continue;
-    }
-    const entry = value;
-    normalized[id] = {
-      enabled: typeof entry.enabled === "boolean" ? entry.enabled : void 0,
-      config: Object.prototype.hasOwnProperty.call(entry, "config") ? entry.config : void 0
-    };
-  }
-  return normalized;
-}
-function normalizePluginsConfig(plugins) {
-  return {
-    enabled: plugins?.enabled !== false,
-    allow: normalizeList(plugins?.allow),
-    deny: normalizeList(plugins?.deny),
-    loadPaths: normalizeList(plugins?.load?.paths),
-    entries: normalizeEntries(plugins?.entries)
-  };
-}
-function resolveEnableState(id, config) {
-  if (!config.enabled) {
-    return { enabled: false, reason: "plugins disabled" };
-  }
-  if (config.deny.includes(id)) {
-    return { enabled: false, reason: "blocked by denylist" };
-  }
-  if (config.allow.length > 0 && !config.allow.includes(id)) {
-    return { enabled: false, reason: "not in allowlist" };
-  }
-  const entry = config.entries[id];
-  if (entry?.enabled === true) {
-    return { enabled: true };
-  }
-  if (entry?.enabled === false) {
-    return { enabled: false, reason: "disabled in config" };
-  }
-  return { enabled: true };
-}
-function recordPluginInstall(config, update) {
-  const { pluginId, ...record } = update;
-  const installs = {
-    ...config.plugins.installs ?? {},
-    [pluginId]: {
-      ...config.plugins.installs?.[pluginId] ?? {},
-      ...record,
-      installedAt: record.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-    }
-  };
-  return {
-    ...config,
-    plugins: {
-      ...config.plugins,
-      installs
-    }
-  };
-}
-function enablePluginInConfig(config, pluginId) {
-  const nextEntries = {
-    ...config.plugins.entries ?? {},
-    [pluginId]: {
-      ...config.plugins.entries?.[pluginId] ?? {},
-      enabled: true
-    }
-  };
-  const allow = config.plugins.allow;
-  const nextAllow = Array.isArray(allow) && allow.length > 0 && !allow.includes(pluginId) ? [...allow, pluginId] : allow;
-  return {
-    ...config,
-    plugins: {
-      ...config.plugins,
-      entries: nextEntries,
-      ...nextAllow ? { allow: nextAllow } : {}
-    }
-  };
-}
-function disablePluginInConfig(config, pluginId) {
-  return {
-    ...config,
-    plugins: {
-      ...config.plugins,
-      entries: {
-        ...config.plugins.entries ?? {},
-        [pluginId]: {
-          ...config.plugins.entries?.[pluginId] ?? {},
-          enabled: false
-        }
-      }
-    }
-  };
-}
-function addPluginLoadPath(config, loadPath) {
-  const paths = Array.from(/* @__PURE__ */ new Set([...config.plugins.load?.paths ?? [], loadPath]));
-  return {
-    ...config,
-    plugins: {
-      ...config.plugins,
-      load: {
-        ...config.plugins.load ?? {},
-        paths
-      }
-    }
-  };
-}
-
-// src/plugins/channel-runtime.ts
-function normalizeChannelId(channel) {
-  return (channel ?? "").trim().toLowerCase();
-}
-function toBinding(registration) {
-  const channelId = registration.channel.id?.trim();
-  if (!channelId) {
-    return null;
-  }
-  return {
-    pluginId: registration.pluginId,
-    channelId,
-    channel: registration.channel
-  };
-}
-function getPluginChannelBindings(registry) {
-  const bindings = [];
-  for (const entry of registry.channels) {
-    const binding = toBinding(entry);
-    if (!binding) {
-      continue;
-    }
-    bindings.push(binding);
-  }
-  return bindings;
-}
-function resolvePluginChannelMessageToolHints(params) {
-  const channelId = normalizeChannelId(params.channel);
-  if (!channelId) {
-    return [];
-  }
-  const binding = getPluginChannelBindings(params.registry).find(
-    (entry) => normalizeChannelId(entry.channelId) === channelId
-  );
-  if (!binding) {
-    return [];
-  }
-  const resolveHints = binding.channel.agentPrompt?.messageToolHints;
-  if (typeof resolveHints !== "function") {
-    return [];
-  }
-  try {
-    const hinted = resolveHints({
-      cfg: params.cfg ?? {},
-      accountId: params.accountId
-    });
-    if (!Array.isArray(hinted)) {
-      return [];
-    }
-    return hinted.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-function getPluginUiMetadataFromRegistry(registry) {
-  return registry.plugins.map((plugin) => ({
-    id: plugin.id,
-    configSchema: plugin.configJsonSchema,
-    configUiHints: plugin.configUiHints
-  }));
-}
-async function startPluginChannelGateways(params) {
-  const logger = params.logger;
-  const diagnostics = [];
-  const handles = [];
-  for (const binding of getPluginChannelBindings(params.registry)) {
-    const gateway = binding.channel.gateway;
-    if (!gateway?.startAccount) {
-      continue;
-    }
-    const accountIdsRaw = binding.channel.config?.listAccountIds?.() ?? [binding.channel.config?.defaultAccountId?.() ?? "default"];
-    const accountIds = Array.from(
-      new Set(accountIdsRaw.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean))
-    );
-    const finalAccountIds = accountIds.length > 0 ? accountIds : ["default"];
-    for (const accountId of finalAccountIds) {
-      try {
-        const started = await gateway.startAccount({
-          accountId,
-          log: logger
-        });
-        handles.push({
-          pluginId: binding.pluginId,
-          channelId: binding.channelId,
-          accountId,
-          stop: started && typeof started === "object" && "stop" in started && typeof started.stop === "function" ? started.stop : void 0
-        });
-      } catch (error) {
-        const raw = String(error);
-        const lower = raw.toLowerCase();
-        const level = lower.includes("required") || lower.includes("not configured") || lower.includes("missing") ? "warn" : "error";
-        const message = `failed to start channel gateway for ${binding.channelId}/${accountId}: ${raw}`;
-        diagnostics.push({
-          level,
-          pluginId: binding.pluginId,
-          message
-        });
-        if (level === "error") {
-          logger?.error(message);
-        } else {
-          logger?.warn(message);
-        }
-      }
-    }
-  }
-  return { handles, diagnostics };
-}
-async function stopPluginChannelGateways(handles) {
-  for (const handle of handles) {
-    if (!handle.stop) {
-      continue;
-    }
-    try {
-      await handle.stop();
-    } catch {
-    }
-  }
-}
-
-// src/plugins/discovery.ts
-import fs2 from "fs";
-import path2 from "path";
-import { expandHome, getDataPath } from "@nextclaw/core";
-
-// src/plugins/manifest.ts
-import fs from "fs";
-import path from "path";
-var PLUGIN_MANIFEST_FILENAME = "openclaw.plugin.json";
-var PLUGIN_MANIFEST_FILENAMES = [PLUGIN_MANIFEST_FILENAME];
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeStringList(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
-}
-function resolvePluginManifestPath(rootDir) {
-  for (const filename of PLUGIN_MANIFEST_FILENAMES) {
-    const candidate = path.join(rootDir, filename);
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  return path.join(rootDir, PLUGIN_MANIFEST_FILENAME);
-}
-function loadPluginManifest(rootDir) {
-  const manifestPath = resolvePluginManifestPath(rootDir);
-  if (!fs.existsSync(manifestPath)) {
-    return { ok: false, error: `plugin manifest not found: ${manifestPath}`, manifestPath };
-  }
-  let raw;
-  try {
-    raw = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-  } catch (err) {
-    return {
-      ok: false,
-      error: `failed to parse plugin manifest: ${String(err)}`,
-      manifestPath
-    };
-  }
-  if (!isRecord(raw)) {
-    return { ok: false, error: "plugin manifest must be an object", manifestPath };
-  }
-  const id = typeof raw.id === "string" ? raw.id.trim() : "";
-  if (!id) {
-    return { ok: false, error: "plugin manifest requires id", manifestPath };
-  }
-  const configSchema = isRecord(raw.configSchema) ? raw.configSchema : null;
-  if (!configSchema) {
-    return { ok: false, error: "plugin manifest requires configSchema", manifestPath };
-  }
-  const manifest = {
-    id,
-    configSchema,
-    kind: typeof raw.kind === "string" ? raw.kind : void 0,
-    channels: normalizeStringList(raw.channels),
-    providers: normalizeStringList(raw.providers),
-    skills: normalizeStringList(raw.skills),
-    name: typeof raw.name === "string" ? raw.name.trim() : void 0,
-    description: typeof raw.description === "string" ? raw.description.trim() : void 0,
-    version: typeof raw.version === "string" ? raw.version.trim() : void 0,
-    uiHints: isRecord(raw.uiHints) ? raw.uiHints : void 0
-  };
-  return { ok: true, manifest, manifestPath };
-}
-function getPackageManifestMetadata(manifest) {
-  if (!manifest) {
-    return void 0;
-  }
-  return manifest.openclaw;
-}
-
-// src/plugins/discovery.ts
-var EXTENSION_EXTS = /* @__PURE__ */ new Set([".ts", ".js", ".mts", ".cts", ".mjs", ".cjs"]);
-function resolveUserPath(input) {
-  return path2.resolve(expandHome(input));
-}
-function isExtensionFile(filePath) {
-  const ext = path2.extname(filePath).toLowerCase();
-  if (!EXTENSION_EXTS.has(ext)) {
-    return false;
-  }
-  return !filePath.endsWith(".d.ts");
-}
-function readPackageManifest(dir) {
-  const manifestPath = path2.join(dir, "package.json");
-  if (!fs2.existsSync(manifestPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function resolvePackageExtensions(manifest) {
-  const raw = getPackageManifestMetadata(manifest)?.extensions;
-  if (!Array.isArray(raw)) {
-    return [];
-  }
-  return raw.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
-}
-function deriveIdHint(params) {
-  const base = path2.basename(params.filePath, path2.extname(params.filePath));
-  const packageName = params.packageName?.trim();
-  if (!packageName) {
-    return base;
-  }
-  const unscoped = packageName.includes("/") ? packageName.split("/").pop() ?? packageName : packageName;
-  if (!params.hasMultipleExtensions) {
-    return unscoped;
-  }
-  return `${unscoped}/${base}`;
-}
-function addCandidate(params) {
-  const resolvedSource = path2.resolve(params.source);
-  if (params.seen.has(resolvedSource)) {
-    return;
-  }
-  params.seen.add(resolvedSource);
-  const manifest = params.manifest ?? null;
-  params.candidates.push({
-    idHint: params.idHint,
-    source: resolvedSource,
-    rootDir: path2.resolve(params.rootDir),
-    origin: params.origin,
-    workspaceDir: params.workspaceDir,
-    packageName: manifest?.name?.trim() || void 0,
-    packageVersion: manifest?.version?.trim() || void 0,
-    packageDescription: manifest?.description?.trim() || void 0,
-    packageDir: params.packageDir
-  });
-}
-function discoverInDirectory(params) {
-  if (!fs2.existsSync(params.dir)) {
-    return;
-  }
-  let entries = [];
-  try {
-    entries = fs2.readdirSync(params.dir, { withFileTypes: true });
-  } catch (err) {
-    params.diagnostics.push({
-      level: "warn",
-      message: `failed to read extensions dir: ${params.dir} (${String(err)})`,
-      source: params.dir
-    });
-    return;
-  }
-  for (const entry of entries) {
-    const fullPath = path2.join(params.dir, entry.name);
-    if (entry.isFile()) {
-      if (!isExtensionFile(fullPath)) {
-        continue;
-      }
-      addCandidate({
-        candidates: params.candidates,
-        seen: params.seen,
-        idHint: path2.basename(entry.name, path2.extname(entry.name)),
-        source: fullPath,
-        rootDir: path2.dirname(fullPath),
-        origin: params.origin,
-        workspaceDir: params.workspaceDir
-      });
-      continue;
-    }
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const manifest = readPackageManifest(fullPath);
-    const extensions = manifest ? resolvePackageExtensions(manifest) : [];
-    if (extensions.length > 0) {
-      for (const extPath of extensions) {
-        const resolved = path2.resolve(fullPath, extPath);
-        addCandidate({
-          candidates: params.candidates,
-          seen: params.seen,
-          idHint: deriveIdHint({
-            filePath: resolved,
-            packageName: manifest?.name,
-            hasMultipleExtensions: extensions.length > 1
-          }),
-          source: resolved,
-          rootDir: fullPath,
-          origin: params.origin,
-          workspaceDir: params.workspaceDir,
-          manifest,
-          packageDir: fullPath
-        });
-      }
-      continue;
-    }
-    const indexCandidates = ["index.ts", "index.js", "index.mjs", "index.cjs"];
-    const indexFile = indexCandidates.map((candidate) => path2.join(fullPath, candidate)).find((candidate) => fs2.existsSync(candidate));
-    if (indexFile && isExtensionFile(indexFile)) {
-      addCandidate({
-        candidates: params.candidates,
-        seen: params.seen,
-        idHint: entry.name,
-        source: indexFile,
-        rootDir: fullPath,
-        origin: params.origin,
-        workspaceDir: params.workspaceDir,
-        manifest,
-        packageDir: fullPath
-      });
-    }
-  }
-}
-function discoverFromPath(params) {
-  const resolved = resolveUserPath(params.rawPath);
-  if (!fs2.existsSync(resolved)) {
-    params.diagnostics.push({
-      level: "error",
-      message: `plugin path not found: ${resolved}`,
-      source: resolved
-    });
-    return;
-  }
-  const stat = fs2.statSync(resolved);
-  if (stat.isFile()) {
-    if (!isExtensionFile(resolved)) {
-      params.diagnostics.push({
-        level: "error",
-        message: `plugin path is not a supported file: ${resolved}`,
-        source: resolved
-      });
-      return;
-    }
-    addCandidate({
-      candidates: params.candidates,
-      seen: params.seen,
-      idHint: path2.basename(resolved, path2.extname(resolved)),
-      source: resolved,
-      rootDir: path2.dirname(resolved),
-      origin: params.origin,
-      workspaceDir: params.workspaceDir
-    });
-    return;
-  }
-  if (stat.isDirectory()) {
-    const manifest = readPackageManifest(resolved);
-    const extensions = manifest ? resolvePackageExtensions(manifest) : [];
-    if (extensions.length > 0) {
-      for (const extPath of extensions) {
-        const source = path2.resolve(resolved, extPath);
-        addCandidate({
-          candidates: params.candidates,
-          seen: params.seen,
-          idHint: deriveIdHint({
-            filePath: source,
-            packageName: manifest?.name,
-            hasMultipleExtensions: extensions.length > 1
-          }),
-          source,
-          rootDir: resolved,
-          origin: params.origin,
-          workspaceDir: params.workspaceDir,
-          manifest,
-          packageDir: resolved
-        });
-      }
-      return;
-    }
-    const indexCandidates = ["index.ts", "index.js", "index.mjs", "index.cjs"];
-    const indexFile = indexCandidates.map((candidate) => path2.join(resolved, candidate)).find((candidate) => fs2.existsSync(candidate));
-    if (indexFile && isExtensionFile(indexFile)) {
-      addCandidate({
-        candidates: params.candidates,
-        seen: params.seen,
-        idHint: path2.basename(resolved),
-        source: indexFile,
-        rootDir: resolved,
-        origin: params.origin,
-        workspaceDir: params.workspaceDir,
-        manifest,
-        packageDir: resolved
-      });
-      return;
-    }
-    discoverInDirectory({
-      dir: resolved,
-      origin: params.origin,
-      workspaceDir: params.workspaceDir,
-      candidates: params.candidates,
-      diagnostics: params.diagnostics,
-      seen: params.seen
-    });
-  }
-}
-function discoverOpenClawPlugins(params) {
-  const candidates = [];
-  const diagnostics = [];
-  const seen = /* @__PURE__ */ new Set();
-  const workspaceDir = params.workspaceDir?.trim();
-  const loadPaths = params.extraPaths ?? params.config?.plugins?.load?.paths ?? [];
-  for (const rawPath of loadPaths) {
-    if (typeof rawPath !== "string") {
-      continue;
-    }
-    const trimmed = rawPath.trim();
-    if (!trimmed) {
-      continue;
-    }
-    discoverFromPath({
-      rawPath: trimmed,
-      origin: "config",
-      workspaceDir,
-      candidates,
-      diagnostics,
-      seen
-    });
-  }
-  if (workspaceDir) {
-    discoverInDirectory({
-      dir: path2.join(workspaceDir, ".nextclaw", "extensions"),
-      origin: "workspace",
-      workspaceDir,
-      candidates,
-      diagnostics,
-      seen
-    });
-  }
-  discoverInDirectory({
-    dir: path2.join(getDataPath(), "extensions"),
-    origin: "global",
-    candidates,
-    diagnostics,
-    seen
-  });
-  return { candidates, diagnostics };
-}
-
-// src/plugins/install.ts
-import fs3 from "fs/promises";
-import os from "os";
-import path3 from "path";
-import { spawn } from "child_process";
-import JSZip from "jszip";
-import * as tar from "tar";
-import { getDataPath as getDataPath2 } from "@nextclaw/core";
-var defaultLogger = {};
-function resolveUserPath2(input) {
-  if (input.startsWith("~/")) {
-    return path3.resolve(os.homedir(), input.slice(2));
-  }
-  return path3.resolve(input);
-}
-function safeDirName(input) {
-  return input.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-/, "").replace(/-$/, "").trim();
-}
-function validatePluginId(pluginId) {
-  if (!pluginId) {
-    return "invalid plugin name: missing";
-  }
-  if (pluginId === "." || pluginId === "..") {
-    return "invalid plugin name: reserved path segment";
-  }
-  if (pluginId.includes("/") || pluginId.includes("\\")) {
-    return "invalid plugin name: path separators not allowed";
-  }
-  return null;
-}
-function resolveExtensionsDir(extensionsDir) {
-  return extensionsDir ? resolveUserPath2(extensionsDir) : path3.join(getDataPath2(), "extensions");
-}
-async function exists(filePath) {
-  try {
-    await fs3.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readJsonFile(filePath) {
-  const raw = await fs3.readFile(filePath, "utf-8");
-  return JSON.parse(raw);
-}
-function resolveArchiveKind(filePath) {
-  const lower = filePath.toLowerCase();
-  if (lower.endsWith(".zip")) {
-    return "zip";
-  }
-  if (lower.endsWith(".tgz") || lower.endsWith(".tar.gz")) {
-    return "tgz";
-  }
-  if (lower.endsWith(".tar")) {
-    return "tar";
-  }
-  return null;
-}
-async function extractArchive(params) {
-  if (params.kind === "zip") {
-    const raw = await fs3.readFile(params.archivePath);
-    const zip = await JSZip.loadAsync(raw);
-    await Promise.all(
-      Object.values(zip.files).map(async (entry) => {
-        const fullPath = path3.resolve(params.destDir, entry.name);
-        if (!fullPath.startsWith(path3.resolve(params.destDir) + path3.sep) && fullPath !== path3.resolve(params.destDir)) {
-          throw new Error(`zip entry escapes destination: ${entry.name}`);
-        }
-        if (entry.dir) {
-          await fs3.mkdir(fullPath, { recursive: true });
-          return;
-        }
-        const parent = path3.dirname(fullPath);
-        await fs3.mkdir(parent, { recursive: true });
-        const content = await entry.async("nodebuffer");
-        await fs3.writeFile(fullPath, content);
-      })
-    );
-    return;
-  }
-  await tar.x({
-    file: params.archivePath,
-    cwd: params.destDir,
-    strict: true,
-    preservePaths: false
-  });
-}
-async function resolvePackedRootDir(extractDir) {
-  const packageDir = path3.join(extractDir, "package");
-  if (await exists(path3.join(packageDir, "package.json"))) {
-    return packageDir;
-  }
-  if (await exists(path3.join(extractDir, "package.json"))) {
-    return extractDir;
-  }
-  const entries = await fs3.readdir(extractDir, { withFileTypes: true });
-  const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path3.join(extractDir, entry.name));
-  if (dirs.length === 1 && await exists(path3.join(dirs[0], "package.json"))) {
-    return dirs[0];
-  }
-  for (const dir of dirs) {
-    if (await exists(path3.join(dir, "package.json"))) {
-      return dir;
-    }
-  }
-  throw new Error("archive missing package root");
-}
-async function ensureOpenClawExtensions(manifest) {
-  const extensions = manifest.openclaw?.extensions;
-  if (!Array.isArray(extensions)) {
-    throw new Error("package.json missing openclaw.extensions");
-  }
-  const list = extensions.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
-  if (list.length === 0) {
-    throw new Error("package.json openclaw.extensions is empty");
-  }
-  return list;
-}
-async function runCommand(command, args, cwd) {
-  return new Promise((resolve) => {
-    const child = spawn(command, args, {
-      cwd,
-      env: {
-        ...process.env,
-        COREPACK_ENABLE_DOWNLOAD_PROMPT: "0",
-        NPM_CONFIG_IGNORE_SCRIPTS: "true"
-      },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("close", (code) => {
-      resolve({ code: code ?? 1, stdout, stderr });
-    });
-    child.on("error", (error) => {
-      resolve({ code: 1, stdout, stderr: `${stderr}
-${String(error)}` });
-    });
-  });
-}
-async function installDependenciesIfNeeded(packageDir, manifest, logger) {
-  if (!manifest.dependencies || Object.keys(manifest.dependencies).length === 0) {
-    return;
-  }
-  logger.info?.("Installing plugin dependencies...");
-  const result = await runCommand("npm", ["install", "--ignore-scripts"], packageDir);
-  if (result.code !== 0) {
-    throw new Error(result.stderr.trim() || result.stdout.trim() || "npm install failed");
-  }
-}
-function resolvePluginInstallDir(pluginId, extensionsDir) {
-  const err = validatePluginId(pluginId);
-  if (err) {
-    throw new Error(err);
-  }
-  const baseDir = resolveExtensionsDir(extensionsDir);
-  const target = path3.resolve(baseDir, pluginId);
-  if (!target.startsWith(path3.resolve(baseDir) + path3.sep) && target !== path3.resolve(baseDir)) {
-    throw new Error("invalid plugin name: path traversal detected");
-  }
-  return target;
-}
-async function installPluginFromPackageDir(params) {
-  const logger = params.logger ?? defaultLogger;
-  const packageDir = resolveUserPath2(params.packageDir);
-  const mode = params.mode ?? "install";
-  const dryRun = params.dryRun ?? false;
-  const packageJsonPath = path3.join(packageDir, "package.json");
-  if (!await exists(packageJsonPath)) {
-    return { ok: false, error: "plugin package missing package.json" };
-  }
-  let packageManifest;
-  try {
-    packageManifest = await readJsonFile(packageJsonPath);
-  } catch (err) {
-    return { ok: false, error: `invalid package.json: ${String(err)}` };
-  }
-  let extensions;
-  try {
-    extensions = await ensureOpenClawExtensions(packageManifest);
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-  const manifestRes = loadPluginManifest(packageDir);
-  if (!manifestRes.ok) {
-    return { ok: false, error: manifestRes.error };
-  }
-  const pluginId = manifestRes.manifest.id;
-  const pluginErr = validatePluginId(pluginId);
-  if (pluginErr) {
-    return { ok: false, error: pluginErr };
-  }
-  if (params.expectedPluginId && params.expectedPluginId !== pluginId) {
-    return {
-      ok: false,
-      error: `plugin id mismatch: expected ${params.expectedPluginId}, got ${pluginId}`
-    };
-  }
-  const targetDir = resolvePluginInstallDir(pluginId, params.extensionsDir);
-  if (mode === "install" && await exists(targetDir)) {
-    return { ok: false, error: `plugin already exists: ${targetDir} (delete it first)` };
-  }
-  if (dryRun) {
-    return {
-      ok: true,
-      pluginId,
-      targetDir,
-      manifestName: packageManifest.name,
-      version: packageManifest.version,
-      extensions
-    };
-  }
-  await fs3.mkdir(path3.dirname(targetDir), { recursive: true });
-  if (mode === "update" && await exists(targetDir)) {
-    await fs3.rm(targetDir, { recursive: true, force: true });
-  }
-  logger.info?.(`Installing to ${targetDir}...`);
-  await fs3.cp(packageDir, targetDir, { recursive: true, force: true });
-  try {
-    for (const extensionPath of extensions) {
-      const resolved = path3.resolve(targetDir, extensionPath);
-      if (!resolved.startsWith(path3.resolve(targetDir) + path3.sep) && resolved !== path3.resolve(targetDir)) {
-        throw new Error(`extension entry escapes plugin directory: ${extensionPath}`);
-      }
-      if (!await exists(resolved)) {
-        throw new Error(`extension entry not found after install: ${extensionPath}`);
-      }
-    }
-    await installDependenciesIfNeeded(targetDir, packageManifest, logger);
-  } catch (err) {
-    await fs3.rm(targetDir, { recursive: true, force: true }).catch(() => void 0);
-    return {
-      ok: false,
-      error: err instanceof Error ? err.message : `failed to install dependencies: ${String(err)}`
-    };
-  }
-  return {
-    ok: true,
-    pluginId,
-    targetDir,
-    manifestName: packageManifest.name,
-    version: packageManifest.version,
-    extensions
-  };
-}
-async function installPluginFromArchive(params) {
-  const logger = params.logger ?? defaultLogger;
-  const archivePath = resolveUserPath2(params.archivePath);
-  if (!await exists(archivePath)) {
-    return { ok: false, error: `archive not found: ${archivePath}` };
-  }
-  const kind = resolveArchiveKind(archivePath);
-  if (!kind) {
-    return { ok: false, error: `unsupported archive: ${archivePath}` };
-  }
-  const tempDir = await fs3.mkdtemp(path3.join(os.tmpdir(), "nextclaw-plugin-"));
-  try {
-    const extractDir = path3.join(tempDir, "extract");
-    await fs3.mkdir(extractDir, { recursive: true });
-    logger.info?.(`Extracting ${archivePath}...`);
-    try {
-      await extractArchive({ archivePath, destDir: extractDir, kind });
-    } catch (err) {
-      return { ok: false, error: `failed to extract archive: ${String(err)}` };
-    }
-    let packageDir = "";
-    try {
-      packageDir = await resolvePackedRootDir(extractDir);
-    } catch (err) {
-      return { ok: false, error: String(err) };
-    }
-    return await installPluginFromPackageDir({
-      packageDir,
-      extensionsDir: params.extensionsDir,
-      logger,
-      mode: params.mode,
-      dryRun: params.dryRun,
-      expectedPluginId: params.expectedPluginId
-    });
-  } finally {
-    await fs3.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
-  }
-}
-async function installPluginFromDir(params) {
-  const dirPath = resolveUserPath2(params.dirPath);
-  if (!await exists(dirPath)) {
-    return { ok: false, error: `directory not found: ${dirPath}` };
-  }
-  const stat = await fs3.stat(dirPath);
-  if (!stat.isDirectory()) {
-    return { ok: false, error: `not a directory: ${dirPath}` };
-  }
-  return installPluginFromPackageDir({
-    packageDir: dirPath,
-    extensionsDir: params.extensionsDir,
-    logger: params.logger,
-    mode: params.mode,
-    dryRun: params.dryRun,
-    expectedPluginId: params.expectedPluginId
-  });
-}
-async function installPluginFromFile(params) {
-  const filePath = resolveUserPath2(params.filePath);
-  const logger = params.logger ?? defaultLogger;
-  const mode = params.mode ?? "install";
-  const dryRun = params.dryRun ?? false;
-  if (!await exists(filePath)) {
-    return { ok: false, error: `file not found: ${filePath}` };
-  }
-  const stat = await fs3.stat(filePath);
-  if (!stat.isFile()) {
-    return { ok: false, error: `not a file: ${filePath}` };
-  }
-  const ext = path3.extname(filePath);
-  const pluginId = safeDirName(path3.basename(filePath, ext) || "plugin");
-  const pluginErr = validatePluginId(pluginId);
-  if (pluginErr) {
-    return { ok: false, error: pluginErr };
-  }
-  const targetDir = resolveExtensionsDir(params.extensionsDir);
-  const targetFile = path3.join(targetDir, `${pluginId}${ext}`);
-  if (mode === "install" && await exists(targetFile)) {
-    return { ok: false, error: `plugin already exists: ${targetFile} (delete it first)` };
-  }
-  if (dryRun) {
-    return {
-      ok: true,
-      pluginId,
-      targetDir: targetFile,
-      extensions: [path3.basename(targetFile)]
-    };
-  }
-  await fs3.mkdir(targetDir, { recursive: true });
-  logger.info?.(`Installing to ${targetFile}...`);
-  await fs3.copyFile(filePath, targetFile);
-  return {
-    ok: true,
-    pluginId,
-    targetDir: targetFile,
-    extensions: [path3.basename(targetFile)]
-  };
-}
-function validateRegistryNpmSpec(spec) {
-  const trimmed = spec.trim();
-  if (!trimmed) {
-    return "npm spec is required";
-  }
-  const lower = trimmed.toLowerCase();
-  if (lower.startsWith("http://") || lower.startsWith("https://") || lower.startsWith("git+") || lower.startsWith("github:") || lower.startsWith("file:")) {
-    return "only registry npm specs are supported";
-  }
-  if (trimmed.includes("/") && !trimmed.startsWith("@")) {
-    return "only registry npm specs are supported";
-  }
-  return null;
-}
-async function installPluginFromNpmSpec(params) {
-  const logger = params.logger ?? defaultLogger;
-  const spec = params.spec.trim();
-  const specError = validateRegistryNpmSpec(spec);
-  if (specError) {
-    return { ok: false, error: specError };
-  }
-  const tempDir = await fs3.mkdtemp(path3.join(os.tmpdir(), "nextclaw-npm-pack-"));
-  try {
-    logger.info?.(`Downloading ${spec}...`);
-    const packed = await runCommand("npm", ["pack", spec, "--ignore-scripts"], tempDir);
-    if (packed.code !== 0) {
-      return {
-        ok: false,
-        error: `npm pack failed: ${packed.stderr.trim() || packed.stdout.trim()}`
-      };
-    }
-    const archiveName = packed.stdout.split("\n").map((line) => line.trim()).filter(Boolean).pop();
-    if (!archiveName) {
-      return { ok: false, error: "npm pack produced no archive" };
-    }
-    const archivePath = path3.join(tempDir, archiveName);
-    return await installPluginFromArchive({
-      archivePath,
-      extensionsDir: params.extensionsDir,
-      logger,
-      mode: params.mode,
-      dryRun: params.dryRun,
-      expectedPluginId: params.expectedPluginId
-    });
-  } finally {
-    await fs3.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
-  }
-}
-async function installPluginFromPath(params) {
-  const resolvedPath = resolveUserPath2(params.path);
-  if (!await exists(resolvedPath)) {
-    return { ok: false, error: `path not found: ${resolvedPath}` };
-  }
-  const stat = await fs3.stat(resolvedPath);
-  if (stat.isDirectory()) {
-    return installPluginFromDir({
-      dirPath: resolvedPath,
-      extensionsDir: params.extensionsDir,
-      logger: params.logger,
-      mode: params.mode,
-      dryRun: params.dryRun,
-      expectedPluginId: params.expectedPluginId
-    });
-  }
-  const archiveKind = resolveArchiveKind(resolvedPath);
-  if (archiveKind) {
-    return installPluginFromArchive({
-      archivePath: resolvedPath,
-      extensionsDir: params.extensionsDir,
-      logger: params.logger,
-      mode: params.mode,
-      dryRun: params.dryRun,
-      expectedPluginId: params.expectedPluginId
-    });
-  }
-  return installPluginFromFile({
-    filePath: resolvedPath,
-    extensionsDir: params.extensionsDir,
-    logger: params.logger,
-    mode: params.mode,
-    dryRun: params.dryRun
-  });
-}
-
-// src/plugins/loader.ts
-import fs5 from "fs";
-import path6 from "path";
-import { fileURLToPath } from "url";
-import { createRequire } from "module";
-import createJitiImport from "jiti";
-import { getWorkspacePathFromConfig } from "@nextclaw/core";
-
-// src/plugins/candidate-filter.ts
-import path4 from "path";
-function isPathInsideRoot(candidatePath, rootPath) {
-  const normalizedCandidate = path4.resolve(candidatePath);
-  const normalizedRoot = path4.resolve(rootPath);
-  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}${path4.sep}`);
-}
-function filterPluginCandidatesByExcludedRoots(candidates, excludedRoots) {
-  const normalizedRoots = excludedRoots.map((entry) => path4.resolve(entry));
-  if (normalizedRoots.length === 0) {
-    return [...candidates];
-  }
-  return candidates.filter((candidate) => {
-    const candidatePaths = [candidate.source, candidate.rootDir, candidate.packageDir].filter(
-      (entry) => typeof entry === "string" && entry.trim().length > 0
-    );
-    return !normalizedRoots.some(
-      (rootPath) => candidatePaths.some((candidatePath) => isPathInsideRoot(candidatePath, rootPath))
-    );
-  });
-}
-
-// src/plugins/manifest-registry.ts
-import fs4 from "fs";
-var PLUGIN_ORIGIN_RANK = {
-  config: 0,
-  workspace: 1,
-  global: 2,
-  bundled: 3
-};
-function safeRealpathSync(rootDir, cache) {
-  const cached = cache.get(rootDir);
-  if (cached) {
-    return cached;
-  }
-  try {
-    const resolved = fs4.realpathSync(rootDir);
-    cache.set(rootDir, resolved);
-    return resolved;
-  } catch {
-    return null;
-  }
-}
-function safeStatMtimeMs(filePath) {
-  try {
-    return fs4.statSync(filePath).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-function normalizeManifestLabel(raw) {
-  const trimmed = raw?.trim();
-  return trimmed ? trimmed : void 0;
-}
-function buildRecord(params) {
-  return {
-    id: params.manifest.id,
-    name: normalizeManifestLabel(params.manifest.name) ?? params.candidate.packageName,
-    description: normalizeManifestLabel(params.manifest.description) ?? params.candidate.packageDescription,
-    version: normalizeManifestLabel(params.manifest.version) ?? params.candidate.packageVersion,
-    kind: params.manifest.kind,
-    channels: params.manifest.channels ?? [],
-    providers: params.manifest.providers ?? [],
-    skills: params.manifest.skills ?? [],
-    origin: params.candidate.origin,
-    workspaceDir: params.candidate.workspaceDir,
-    rootDir: params.candidate.rootDir,
-    source: params.candidate.source,
-    manifestPath: params.manifestPath,
-    schemaCacheKey: params.schemaCacheKey,
-    configSchema: params.configSchema,
-    configUiHints: params.manifest.uiHints
-  };
-}
-function loadPluginManifestRegistry(params) {
-  const normalized = normalizePluginsConfig(params.config?.plugins);
-  const discovery = params.candidates ? {
-    candidates: params.candidates,
-    diagnostics: params.diagnostics ?? []
-  } : discoverOpenClawPlugins({
-    config: params.config,
-    workspaceDir: params.workspaceDir,
-    extraPaths: normalized.loadPaths
-  });
-  const diagnostics = [...discovery.diagnostics];
-  const records = [];
-  const seenIds = /* @__PURE__ */ new Map();
-  const realpathCache = /* @__PURE__ */ new Map();
-  for (const candidate of discovery.candidates) {
-    const manifestRes = loadPluginManifest(candidate.rootDir);
-    if (!manifestRes.ok) {
-      diagnostics.push({
-        level: "error",
-        message: manifestRes.error,
-        source: manifestRes.manifestPath
-      });
-      continue;
-    }
-    const manifest = manifestRes.manifest;
-    const configSchema = manifest.configSchema;
-    if (candidate.idHint && candidate.idHint !== manifest.id) {
-      diagnostics.push({
-        level: "warn",
-        pluginId: manifest.id,
-        source: candidate.source,
-        message: `plugin id mismatch (manifest uses "${manifest.id}", entry hints "${candidate.idHint}")`
-      });
-    }
-    const manifestMtime = safeStatMtimeMs(manifestRes.manifestPath);
-    const schemaCacheKey = manifestMtime ? `${manifestRes.manifestPath}:${manifestMtime}` : manifestRes.manifestPath;
-    const existing = seenIds.get(manifest.id);
-    if (existing) {
-      const existingReal = safeRealpathSync(existing.candidate.rootDir, realpathCache);
-      const candidateReal = safeRealpathSync(candidate.rootDir, realpathCache);
-      const samePlugin = Boolean(existingReal && candidateReal && existingReal === candidateReal);
-      if (samePlugin) {
-        if (PLUGIN_ORIGIN_RANK[candidate.origin] < PLUGIN_ORIGIN_RANK[existing.candidate.origin]) {
-          records[existing.recordIndex] = buildRecord({
-            manifest,
-            candidate,
-            manifestPath: manifestRes.manifestPath,
-            schemaCacheKey,
-            configSchema
-          });
-          seenIds.set(manifest.id, { candidate, recordIndex: existing.recordIndex });
-        }
-        continue;
-      }
-      diagnostics.push({
-        level: "warn",
-        pluginId: manifest.id,
-        source: candidate.source,
-        message: `duplicate plugin id detected; later plugin may be overridden (${candidate.source})`
-      });
-    } else {
-      seenIds.set(manifest.id, { candidate, recordIndex: records.length });
-    }
-    records.push(
-      buildRecord({
-        manifest,
-        candidate,
-        manifestPath: manifestRes.manifestPath,
-        schemaCacheKey,
-        configSchema
-      })
-    );
-  }
-  return {
-    plugins: records,
-    diagnostics
-  };
-}
-function toPluginUiMetadata(records) {
-  return records.map((record) => ({
-    id: record.id,
-    configSchema: record.configSchema,
-    configUiHints: record.configUiHints
-  }));
-}
-function loadPluginUiMetadata(params) {
-  const registry = loadPluginManifestRegistry({
-    config: params.config,
-    workspaceDir: params.workspaceDir
-  });
-  return toPluginUiMetadata(registry.plugins);
-}
-
-// src/plugins/schema-validator.ts
-import AjvPkg from "ajv";
-var AjvCtor = AjvPkg;
-var ajv = new AjvCtor({
-  allErrors: true,
-  strict: false,
-  removeAdditional: false
-});
-var schemaCache = /* @__PURE__ */ new Map();
-function formatAjvErrors(errors) {
-  if (!errors || errors.length === 0) {
-    return ["invalid config"];
-  }
-  return errors.map((error) => {
-    const path8 = error.instancePath?.replace(/^\//, "").replace(/\//g, ".") || "<root>";
-    const message = error.message ?? "invalid";
-    return `${path8}: ${message}`;
-  });
-}
-function validateJsonSchemaValue(params) {
-  let cached = schemaCache.get(params.cacheKey);
-  if (!cached || cached.schema !== params.schema) {
-    const validate = ajv.compile(params.schema);
-    cached = { validate, schema: params.schema };
-    schemaCache.set(params.cacheKey, cached);
-  }
-  const ok = cached.validate(params.value);
-  if (ok) {
-    return { ok: true };
-  }
-  return { ok: false, errors: formatAjvErrors(cached.validate.errors) };
-}
-
-// src/plugins/plugin-loader-utils.ts
-function createPluginRecord(params) {
-  return {
-    id: params.id,
-    name: params.name ?? params.id,
-    description: params.description,
-    version: params.version,
-    kind: params.kind,
-    source: params.source,
-    origin: params.origin,
-    workspaceDir: params.workspaceDir,
-    enabled: params.enabled,
-    status: params.enabled ? "loaded" : "disabled",
-    toolNames: [],
-    channelIds: [],
-    providerIds: [],
-    engineKinds: [],
-    ncpAgentRuntimeKinds: [],
-    configSchema: params.configSchema,
-    configUiHints: params.configUiHints,
-    configJsonSchema: params.configJsonSchema
-  };
-}
-function isPlaceholderConfigSchema(schema) {
-  if (!schema || typeof schema !== "object") {
-    return false;
-  }
-  const type = schema.type;
-  const isObjectType = type === "object" || Array.isArray(type) && type.includes("object");
-  if (!isObjectType) {
-    return false;
-  }
-  const properties = schema.properties;
-  const noProperties = !properties || typeof properties === "object" && !Array.isArray(properties) && Object.keys(properties).length === 0;
-  return noProperties && schema.additionalProperties === false;
-}
-function validatePluginConfig(params) {
-  if (!params.schema || isPlaceholderConfigSchema(params.schema)) {
-    return { ok: true, value: params.value };
-  }
-  const cacheKey = params.cacheKey ?? JSON.stringify(params.schema);
-  const result = validateJsonSchemaValue({
-    schema: params.schema,
-    cacheKey,
-    value: params.value ?? {}
-  });
-  if (result.ok) {
-    return { ok: true, value: params.value };
-  }
-  return { ok: false, errors: result.errors };
-}
-
-// src/plugins/registry.ts
-import path5 from "path";
-import { expandHome as expandHome2 } from "@nextclaw/core";
-
-// src/plugins/plugin-capability-registration.ts
-function ensureUniqueNames(params) {
-  const accepted = [];
-  for (const rawName of params.names) {
-    const name = rawName.trim();
-    if (!name) {
-      continue;
-    }
-    if (params.reserved.has(name)) {
-      params.diagnostics.push({
-        level: "error",
-        pluginId: params.pluginId,
-        source: params.source,
-        message: `${params.kind} already registered by core: ${name}`
-      });
-      continue;
-    }
-    const owner = params.owners.get(name);
-    if (owner && owner !== params.pluginId) {
-      params.diagnostics.push({
-        level: "error",
-        pluginId: params.pluginId,
-        source: params.source,
-        message: `${params.kind} already registered: ${name} (${owner})`
-      });
-      continue;
-    }
-    params.owners.set(name, params.pluginId);
-    accepted.push(name);
-  }
-  return accepted;
-}
-function registerPluginEngine(params) {
-  const accepted = ensureUniqueNames({
-    names: [params.kind],
-    pluginId: params.pluginId,
-    diagnostics: params.runtime.registry.diagnostics,
-    source: params.source,
-    owners: params.runtime.engineKindOwners,
-    reserved: params.runtime.reservedEngineKinds,
-    kind: "engine"
-  });
-  if (accepted.length === 0) {
-    return;
-  }
-  params.runtime.registry.engines.push({
-    pluginId: params.pluginId,
-    kind: accepted[0],
-    factory: params.factory,
-    source: params.source
-  });
-  params.record.engineKinds.push(accepted[0]);
-}
-function registerPluginNcpAgentRuntime(params) {
-  const rawKind = params.registration.kind?.trim().toLowerCase();
-  if (!rawKind) {
-    params.runtime.registry.diagnostics.push({
-      level: "error",
-      pluginId: params.pluginId,
-      source: params.source,
-      message: "registerNcpAgentRuntime requires registration.kind"
-    });
-    return;
-  }
-  const accepted = ensureUniqueNames({
-    names: [rawKind],
-    pluginId: params.pluginId,
-    diagnostics: params.runtime.registry.diagnostics,
-    source: params.source,
-    owners: params.runtime.ncpAgentRuntimeKindOwners,
-    reserved: params.runtime.reservedNcpAgentRuntimeKinds,
-    kind: "ncp-runtime"
-  });
-  if (accepted.length === 0) {
-    return;
-  }
-  params.runtime.registry.ncpAgentRuntimes.push({
-    pluginId: params.pluginId,
-    kind: accepted[0],
-    label: params.registration.label?.trim() || accepted[0],
-    createRuntime: params.registration.createRuntime,
-    source: params.source
-  });
-  params.record.ncpAgentRuntimeKinds.push(accepted[0]);
-}
-
-// src/plugins/runtime.ts
-import { getPackageVersion } from "@nextclaw/core";
-import { MemoryGetTool, MemorySearchTool } from "@nextclaw/core";
-var bridge = {};
-function setPluginRuntimeBridge(next) {
-  bridge = next ?? {};
-}
-function toPluginTool(tool) {
-  return {
-    name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters,
-    execute: (params) => tool.execute(params)
-  };
-}
-function loadConfigWithFallback(config) {
-  if (bridge.loadConfig) {
-    return bridge.loadConfig();
-  }
-  return config ?? {};
-}
-async function writeConfigWithFallback(next) {
-  if (!bridge.writeConfigFile) {
-    throw new Error("plugin runtime config.writeConfigFile is unavailable outside gateway runtime");
-  }
-  await bridge.writeConfigFile(next);
-}
-async function dispatchReplyWithFallback(params) {
-  if (!bridge.dispatchReplyWithBufferedBlockDispatcher) {
-    throw new Error("plugin runtime channel.reply dispatcher is unavailable outside gateway runtime");
-  }
-  await bridge.dispatchReplyWithBufferedBlockDispatcher(params);
-}
-function createPluginRuntime(params) {
-  return {
-    version: getPackageVersion(),
-    config: {
-      loadConfig: () => loadConfigWithFallback(params.config),
-      writeConfigFile: async (next) => writeConfigWithFallback(next)
-    },
-    tools: {
-      createMemorySearchTool: () => toPluginTool(new MemorySearchTool(params.workspace)),
-      createMemoryGetTool: () => toPluginTool(new MemoryGetTool(params.workspace))
-    },
-    channel: {
-      reply: {
-        dispatchReplyWithBufferedBlockDispatcher: async (dispatchParams) => dispatchReplyWithFallback(dispatchParams)
-      }
-    }
-  };
-}
-
-// src/plugins/registry.ts
-function buildPluginLogger(base, pluginId) {
-  const withPrefix = (message) => `[plugins:${pluginId}] ${message}`;
-  return {
-    info: (message) => base.info(withPrefix(message)),
-    warn: (message) => base.warn(withPrefix(message)),
-    error: (message) => base.error(withPrefix(message)),
-    debug: base.debug ? (message) => base.debug?.(withPrefix(message)) : void 0
-  };
-}
-function normalizeToolList(value) {
-  if (!value) {
-    return [];
-  }
-  const list = Array.isArray(value) ? value : [value];
-  return list.filter((entry) => {
-    if (!entry || typeof entry !== "object") {
-      return false;
-    }
-    const candidate = entry;
-    return typeof candidate.name === "string" && candidate.name.trim().length > 0 && candidate.parameters !== void 0 && typeof candidate.execute === "function";
-  });
-}
-function createPluginRegisterRuntime(params) {
-  return {
-    config: params.config,
-    workspaceDir: params.workspaceDir,
-    logger: params.logger,
-    registry: params.registry,
-    toolNameOwners: /* @__PURE__ */ new Map(),
-    channelIdOwners: /* @__PURE__ */ new Map(),
-    providerIdOwners: /* @__PURE__ */ new Map(),
-    engineKindOwners: /* @__PURE__ */ new Map(),
-    ncpAgentRuntimeKindOwners: /* @__PURE__ */ new Map(),
-    resolvedToolNames: /* @__PURE__ */ new Set(),
-    reservedToolNames: params.reservedToolNames,
-    reservedChannelIds: params.reservedChannelIds,
-    reservedProviderIds: params.reservedProviderIds,
-    reservedEngineKinds: params.reservedEngineKinds,
-    reservedNcpAgentRuntimeKinds: params.reservedNcpAgentRuntimeKinds
-  };
-}
-function registerPluginTool(params) {
-  const toolInput = params.tool;
-  const normalizedNames = [];
-  if (Array.isArray(params.opts?.names)) {
-    for (const name of params.opts?.names ?? []) {
-      const trimmed = String(name).trim();
-      if (trimmed) {
-        normalizedNames.push(trimmed);
-      }
-    }
-  } else if (params.opts?.name && String(params.opts.name).trim()) {
-    normalizedNames.push(String(params.opts.name).trim());
-  }
-  if (typeof toolInput !== "function") {
-    const intrinsic = toolInput.name.trim();
-    if (intrinsic) {
-      normalizedNames.push(intrinsic);
-    }
-  }
-  const acceptedNames = ensureUniqueNames({
-    names: normalizedNames,
-    pluginId: params.pluginId,
-    diagnostics: params.runtime.registry.diagnostics,
-    source: params.source,
-    owners: params.runtime.toolNameOwners,
-    reserved: params.runtime.reservedToolNames,
-    kind: "tool"
-  });
-  if (acceptedNames.length === 0) {
-    return;
-  }
-  const factory = typeof toolInput === "function" ? toolInput : () => toolInput;
-  const registration = {
-    pluginId: params.pluginId,
-    factory,
-    names: acceptedNames,
-    optional: params.opts?.optional === true,
-    source: params.source
-  };
-  params.runtime.registry.tools.push(registration);
-  params.record.toolNames.push(...acceptedNames);
-  if (typeof toolInput === "function") {
-    return;
-  }
-  if (!params.runtime.resolvedToolNames.has(toolInput.name)) {
-    params.runtime.resolvedToolNames.add(toolInput.name);
-    params.runtime.registry.resolvedTools.push(toolInput);
-  }
-}
-function registerPluginChannel(params) {
-  const normalizedChannel = params.registration && typeof params.registration === "object" && "plugin" in params.registration ? params.registration.plugin : params.registration;
-  if (!normalizedChannel || typeof normalizedChannel !== "object") {
-    params.runtime.registry.diagnostics.push({
-      level: "error",
-      pluginId: params.pluginId,
-      source: params.source,
-      message: "channel registration missing plugin object"
-    });
-    return;
-  }
-  const channelObj = normalizedChannel;
-  const rawId = typeof channelObj.id === "string" ? channelObj.id : String(channelObj.id ?? "");
-  const accepted = ensureUniqueNames({
-    names: [rawId],
-    pluginId: params.pluginId,
-    diagnostics: params.runtime.registry.diagnostics,
-    source: params.source,
-    owners: params.runtime.channelIdOwners,
-    reserved: params.runtime.reservedChannelIds,
-    kind: "channel"
-  });
-  if (accepted.length === 0) {
-    return;
-  }
-  const channelPlugin = normalizedChannel;
-  params.runtime.registry.channels.push({
-    pluginId: params.pluginId,
-    channel: channelPlugin,
-    source: params.source
-  });
-  const channelId = accepted[0];
-  params.record.channelIds.push(channelId);
-  const configSchema = channelPlugin.configSchema;
-  if (configSchema && typeof configSchema === "object") {
-    const schema = configSchema.schema;
-    if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-      params.record.configJsonSchema = schema;
-      params.record.configSchema = true;
-    }
-    const uiHints = configSchema.uiHints;
-    if (uiHints && typeof uiHints === "object" && !Array.isArray(uiHints)) {
-      params.record.configUiHints = {
-        ...params.record.configUiHints ?? {},
-        ...uiHints
-      };
-    }
-  }
-  const pushChannelTools = (value, optional, sourceLabel, resolveValue) => {
-    const previewTools = normalizeToolList(value);
-    if (previewTools.length === 0) {
-      return;
-    }
-    const declaredNames = previewTools.map((tool) => tool.name);
-    const acceptedNames = ensureUniqueNames({
-      names: declaredNames,
-      pluginId: params.pluginId,
-      diagnostics: params.runtime.registry.diagnostics,
-      source: params.source,
-      owners: params.runtime.toolNameOwners,
-      reserved: params.runtime.reservedToolNames,
-      kind: "tool"
-    });
-    if (acceptedNames.length === 0) {
-      return;
-    }
-    const factory = (ctx) => {
-      const tools = normalizeToolList(resolveValue(ctx));
-      if (tools.length === 0) {
-        return [];
-      }
-      const byName = new Map(tools.map((tool) => [tool.name, tool]));
-      return acceptedNames.map((name) => byName.get(name)).filter(Boolean);
-    };
-    params.runtime.registry.tools.push({
-      pluginId: params.pluginId,
-      factory,
-      names: acceptedNames,
-      optional,
-      source: params.source
-    });
-    params.record.toolNames.push(...acceptedNames);
-    const previewByName = new Map(previewTools.map((tool) => [tool.name, tool]));
-    for (const name of acceptedNames) {
-      const resolvedTool = previewByName.get(name);
-      if (!resolvedTool || params.runtime.resolvedToolNames.has(resolvedTool.name)) {
-        continue;
-      }
-      params.runtime.resolvedToolNames.add(resolvedTool.name);
-      params.runtime.registry.resolvedTools.push(resolvedTool);
-    }
-    params.runtime.registry.diagnostics.push({
-      level: "warn",
-      pluginId: params.pluginId,
-      source: params.source,
-      message: `${sourceLabel} registered channel-owned tools: ${acceptedNames.join(", ")}`
-    });
-  };
-  const agentTools = channelPlugin.agentTools;
-  if (typeof agentTools === "function") {
-    pushChannelTools(
-      normalizeToolList(agentTools()),
-      false,
-      `channel "${channelId}"`,
-      () => agentTools()
-    );
-  } else if (agentTools) {
-    pushChannelTools(normalizeToolList(agentTools), false, `channel "${channelId}"`, () => agentTools);
-  }
-}
-function registerPluginProvider(params) {
-  const accepted = ensureUniqueNames({
-    names: [params.provider.id],
-    pluginId: params.pluginId,
-    diagnostics: params.runtime.registry.diagnostics,
-    source: params.source,
-    owners: params.runtime.providerIdOwners,
-    reserved: params.runtime.reservedProviderIds,
-    kind: "provider"
-  });
-  if (accepted.length === 0) {
-    return;
-  }
-  params.runtime.registry.providers.push({
-    pluginId: params.pluginId,
-    provider: params.provider,
-    source: params.source
-  });
-  params.record.providerIds.push(accepted[0]);
-}
-function registerPluginWithApi(params) {
-  const pluginRuntime = createPluginRuntime({ workspace: params.runtime.workspaceDir, config: params.runtime.config });
-  const pluginLogger = buildPluginLogger(params.runtime.logger, params.pluginId);
-  const pushUnsupported = (capability) => {
-    params.runtime.registry.diagnostics.push({
-      level: "warn",
-      pluginId: params.pluginId,
-      source: params.source,
-      message: `${capability} is not supported by nextclaw compat layer yet`
-    });
-    pluginLogger.warn(`${capability} is ignored (not supported yet)`);
-  };
-  const api = {
-    id: params.pluginId,
-    name: params.record.name,
-    version: params.record.version,
-    description: params.record.description,
-    source: params.source,
-    config: params.runtime.config,
-    pluginConfig: params.pluginConfig,
-    runtime: pluginRuntime,
-    logger: pluginLogger,
-    registerTool: (tool, opts) => {
-      registerPluginTool({
-        runtime: params.runtime,
-        record: params.record,
-        pluginId: params.pluginId,
-        source: params.source,
-        tool,
-        opts
-      });
-    },
-    registerChannel: (registration) => {
-      registerPluginChannel({
-        runtime: params.runtime,
-        record: params.record,
-        pluginId: params.pluginId,
-        source: params.source,
-        registration
-      });
-    },
-    registerProvider: (provider) => {
-      registerPluginProvider({
-        runtime: params.runtime,
-        record: params.record,
-        pluginId: params.pluginId,
-        source: params.source,
-        provider
-      });
-    },
-    registerEngine: (factory, opts) => {
-      const kind = opts?.kind?.trim().toLowerCase();
-      if (!kind) {
-        params.runtime.registry.diagnostics.push({
-          level: "error",
-          pluginId: params.pluginId,
-          source: params.source,
-          message: "registerEngine requires opts.kind"
-        });
-        return;
-      }
-      registerPluginEngine({
-        runtime: params.runtime,
-        record: params.record,
-        pluginId: params.pluginId,
-        source: params.source,
-        kind,
-        factory
-      });
-    },
-    registerNcpAgentRuntime: (registration) => {
-      registerPluginNcpAgentRuntime({
-        runtime: params.runtime,
-        record: params.record,
-        pluginId: params.pluginId,
-        source: params.source,
-        registration
-      });
-    },
-    registerHook: () => pushUnsupported("registerHook"),
-    registerGatewayMethod: () => pushUnsupported("registerGatewayMethod"),
-    registerCli: () => pushUnsupported("registerCli"),
-    registerService: () => pushUnsupported("registerService"),
-    registerCommand: () => pushUnsupported("registerCommand"),
-    registerHttpHandler: () => pushUnsupported("registerHttpHandler"),
-    registerHttpRoute: () => pushUnsupported("registerHttpRoute"),
-    resolvePath: (input) => {
-      const trimmed = input.trim();
-      if (!trimmed) {
-        return params.rootDir;
-      }
-      if (path5.isAbsolute(trimmed)) {
-        return path5.resolve(expandHome2(trimmed));
-      }
-      return path5.resolve(params.rootDir, trimmed);
-    }
-  };
-  try {
-    const result = params.register(api);
-    if (result && typeof result === "object" && "then" in result) {
-      params.runtime.registry.diagnostics.push({
-        level: "warn",
-        pluginId: params.pluginId,
-        source: params.source,
-        message: "plugin register returned a promise; async registration is ignored"
-      });
-    }
-    return { ok: true };
-  } catch (err) {
-    const error = `plugin failed during register: ${String(err)}`;
-    return { ok: false, error };
-  }
-}
-
-// src/plugins/loader.ts
-var createJiti = createJitiImport;
-var defaultLogger2 = {
-  info: (message) => console.log(message),
-  warn: (message) => console.warn(message),
-  error: (message) => console.error(message),
-  debug: (message) => console.debug(message)
-};
-var BUNDLED_CHANNEL_PLUGIN_PACKAGES = [
-  "@nextclaw/channel-plugin-telegram",
-  "@nextclaw/channel-plugin-whatsapp",
-  "@nextclaw/channel-plugin-discord",
-  "@nextclaw/channel-plugin-feishu",
-  "@nextclaw/channel-plugin-mochat",
-  "@nextclaw/channel-plugin-dingtalk",
-  "@nextclaw/channel-plugin-wecom",
-  "@nextclaw/channel-plugin-email",
-  "@nextclaw/channel-plugin-slack",
-  "@nextclaw/channel-plugin-qq"
-];
-function resolvePackageRootFromEntry(entryFile) {
-  let cursor = path6.dirname(entryFile);
-  for (let i = 0; i < 8; i += 1) {
-    const candidate = path6.join(cursor, "package.json");
-    if (fs5.existsSync(candidate)) {
-      return cursor;
-    }
-    const parent = path6.dirname(cursor);
-    if (parent === cursor) {
-      break;
-    }
-    cursor = parent;
-  }
-  return path6.dirname(entryFile);
-}
-function resolvePluginSdkAliasFile(params) {
-  try {
-    const modulePath = fileURLToPath(import.meta.url);
-    const isProduction = process.env.NODE_ENV === "production";
-    let cursor = path6.dirname(modulePath);
-    for (let i = 0; i < 6; i += 1) {
-      const srcCandidate = path6.join(cursor, "src", "plugin-sdk", params.srcFile);
-      const distCandidate = path6.join(cursor, "dist", "plugin-sdk", params.distFile);
-      const candidates = isProduction ? [distCandidate, srcCandidate] : [srcCandidate, distCandidate];
-      for (const candidate of candidates) {
-        if (fs5.existsSync(candidate)) {
-          return candidate;
-        }
-      }
-      const parent = path6.dirname(cursor);
-      if (parent === cursor) {
-        break;
-      }
-      cursor = parent;
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-function resolvePluginSdkAlias() {
-  return resolvePluginSdkAliasFile({ srcFile: "index.ts", distFile: "index.js" });
-}
-function buildScopedPackageAliases(scope) {
-  const aliases = {};
-  const require2 = createRequire(import.meta.url);
-  let cursor = path6.dirname(fileURLToPath(import.meta.url));
-  for (let i = 0; i < 8; i += 1) {
-    const scopeDir = path6.join(cursor, "node_modules", scope);
-    if (fs5.existsSync(scopeDir)) {
-      let entries = [];
-      try {
-        entries = fs5.readdirSync(scopeDir, { withFileTypes: true });
-      } catch {
-        entries = [];
-      }
-      for (const entry of entries) {
-        if (!entry.isDirectory() && !entry.isSymbolicLink()) {
-          continue;
-        }
-        const packageName = `${scope}/${entry.name}`;
-        try {
-          aliases[packageName] = require2.resolve(packageName);
-        } catch {
-        }
-      }
-    }
-    const parent = path6.dirname(cursor);
-    if (parent === cursor) {
-      break;
-    }
-    cursor = parent;
-  }
-  return aliases;
-}
-function buildPluginLoaderAliases() {
-  const aliases = buildScopedPackageAliases("@nextclaw");
-  const pluginSdkAlias = resolvePluginSdkAlias();
-  if (pluginSdkAlias) {
-    aliases["openclaw/plugin-sdk"] = pluginSdkAlias;
-  }
-  return aliases;
-}
-function resolvePluginModuleExport(moduleExport) {
-  const resolved = moduleExport && typeof moduleExport === "object" && "default" in moduleExport ? moduleExport.default : moduleExport;
-  if (typeof resolved === "function") {
-    return {
-      register: resolved
-    };
-  }
-  if (resolved && typeof resolved === "object") {
-    const definition = resolved;
-    return {
-      definition,
-      register: definition.register ?? definition.activate
-    };
-  }
-  return {};
-}
-function appendBundledChannelPlugins(params) {
-  const require2 = createRequire(import.meta.url);
-  for (const packageName of BUNDLED_CHANNEL_PLUGIN_PACKAGES) {
-    let entryFile = "";
-    let rootDir = "";
-    try {
-      entryFile = require2.resolve(packageName);
-      rootDir = resolvePackageRootFromEntry(entryFile);
-    } catch (err) {
-      params.registry.diagnostics.push({
-        level: "error",
-        source: packageName,
-        message: `bundled plugin package not resolvable: ${String(err)}`
-      });
-      continue;
-    }
-    let moduleExport = null;
-    try {
-      moduleExport = params.jiti(entryFile);
-    } catch (err) {
-      params.registry.diagnostics.push({
-        level: "error",
-        source: entryFile,
-        message: `failed to load bundled plugin: ${String(err)}`
-      });
-      continue;
-    }
-    const resolved = resolvePluginModuleExport(moduleExport);
-    const definition = resolved.definition;
-    const register = resolved.register;
-    const pluginId = typeof definition?.id === "string" ? definition.id.trim() : "";
-    const source = entryFile;
-    if (!pluginId) {
-      params.registry.diagnostics.push({
-        level: "error",
-        source,
-        message: "bundled plugin definition missing id"
-      });
-      continue;
-    }
-    const enableState = resolveEnableState(pluginId, params.normalizedConfig);
-    const record = createPluginRecord({
-      id: pluginId,
-      name: definition?.name ?? pluginId,
-      description: definition?.description,
-      version: definition?.version,
-      kind: definition?.kind,
-      source,
-      origin: "bundled",
-      workspaceDir: params.runtime.workspaceDir,
-      enabled: enableState.enabled,
-      configSchema: Boolean(definition?.configSchema),
-      configJsonSchema: definition?.configSchema
-    });
-    if (!enableState.enabled) {
-      record.status = "disabled";
-      record.error = enableState.reason;
-      params.registry.plugins.push(record);
-      continue;
-    }
-    if (typeof register !== "function") {
-      record.status = "error";
-      record.error = "plugin export missing register/activate";
-      params.registry.plugins.push(record);
-      params.registry.diagnostics.push({
-        level: "error",
-        pluginId,
-        source,
-        message: record.error
-      });
-      continue;
-    }
-    const result = registerPluginWithApi({
-      runtime: params.runtime,
-      record,
-      pluginId,
-      source,
-      rootDir,
-      register,
-      pluginConfig: void 0
-    });
-    if (!result.ok) {
-      record.status = "error";
-      record.error = result.error;
-      params.registry.diagnostics.push({
-        level: "error",
-        pluginId,
-        source,
-        message: result.error
-      });
-    }
-    params.registry.plugins.push(record);
-  }
-}
-function loadOpenClawPlugins(options) {
-  const loadExternalPlugins = process.env.NEXTCLAW_ENABLE_OPENCLAW_PLUGINS !== "0";
-  const logger = options.logger ?? defaultLogger2;
-  const workspaceDir = options.workspaceDir?.trim() || getWorkspacePathFromConfig(options.config);
-  const normalized = normalizePluginsConfig(options.config.plugins);
-  const mode = options.mode ?? "full";
-  const registry = {
-    plugins: [],
-    tools: [],
-    channels: [],
-    providers: [],
-    engines: [],
-    ncpAgentRuntimes: [],
-    diagnostics: [],
-    resolvedTools: []
-  };
-  const reservedToolNames = new Set(options.reservedToolNames ?? []);
-  const reservedChannelIds = new Set(options.reservedChannelIds ?? []);
-  const reservedProviderIds = new Set(options.reservedProviderIds ?? []);
-  const reservedEngineKinds = new Set((options.reservedEngineKinds ?? ["native"]).map((entry) => entry.toLowerCase()));
-  const reservedNcpAgentRuntimeKinds = new Set(
-    (options.reservedNcpAgentRuntimeKinds ?? ["native"]).map((entry) => entry.toLowerCase())
-  );
-  const registerRuntime = createPluginRegisterRuntime({
-    config: options.config,
-    workspaceDir,
-    logger,
-    registry,
-    reservedToolNames,
-    reservedChannelIds,
-    reservedProviderIds,
-    reservedEngineKinds,
-    reservedNcpAgentRuntimeKinds
-  });
-  const jiti = createJiti(import.meta.url, {
-    interopDefault: true,
-    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
-    alias: buildPluginLoaderAliases()
-  });
-  appendBundledChannelPlugins({
-    registry,
-    runtime: registerRuntime,
-    jiti,
-    normalizedConfig: normalized
-  });
-  if (!loadExternalPlugins) {
-    return registry;
-  }
-  const discovery = discoverOpenClawPlugins({
-    config: options.config,
-    workspaceDir,
-    extraPaths: normalized.loadPaths
-  });
-  const filteredCandidates = filterPluginCandidatesByExcludedRoots(discovery.candidates, options.excludeRoots ?? []);
-  const manifestRegistry = loadPluginManifestRegistry({
-    config: options.config,
-    workspaceDir,
-    candidates: filteredCandidates,
-    diagnostics: discovery.diagnostics
-  });
-  registry.diagnostics.push(...manifestRegistry.diagnostics);
-  const manifestByRoot = new Map(manifestRegistry.plugins.map((entry) => [entry.rootDir, entry]));
-  const seenIds = new Map(
-    registry.plugins.map((entry) => [entry.id, entry.origin])
-  );
-  for (const candidate of filteredCandidates) {
-    const manifest = manifestByRoot.get(candidate.rootDir);
-    if (!manifest) {
-      continue;
-    }
-    const pluginId = manifest.id;
-    const existingOrigin = seenIds.get(pluginId);
-    if (existingOrigin) {
-      const record2 = createPluginRecord({
-        id: pluginId,
-        name: manifest.name ?? pluginId,
-        description: manifest.description,
-        version: manifest.version,
-        kind: manifest.kind,
-        source: candidate.source,
-        origin: candidate.origin,
-        workspaceDir: candidate.workspaceDir,
-        enabled: false,
-        configSchema: Boolean(manifest.configSchema),
-        configUiHints: manifest.configUiHints,
-        configJsonSchema: manifest.configSchema
-      });
-      record2.status = "disabled";
-      record2.error = `overridden by ${existingOrigin} plugin`;
-      registry.plugins.push(record2);
-      continue;
-    }
-    const enableState = resolveEnableState(pluginId, normalized);
-    const entry = normalized.entries[pluginId];
-    const record = createPluginRecord({
-      id: pluginId,
-      name: manifest.name ?? pluginId,
-      description: manifest.description,
-      version: manifest.version,
-      kind: manifest.kind,
-      source: candidate.source,
-      origin: candidate.origin,
-      workspaceDir: candidate.workspaceDir,
-      enabled: enableState.enabled,
-      configSchema: Boolean(manifest.configSchema),
-      configUiHints: manifest.configUiHints,
-      configJsonSchema: manifest.configSchema
-    });
-    if (!enableState.enabled) {
-      record.status = "disabled";
-      record.error = enableState.reason;
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
-      continue;
-    }
-    if (!manifest.configSchema) {
-      record.status = "error";
-      record.error = "missing config schema";
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
-      registry.diagnostics.push({
-        level: "error",
-        pluginId,
-        source: candidate.source,
-        message: record.error
-      });
-      continue;
-    }
-    const validatedConfig = validatePluginConfig({
-      schema: manifest.configSchema,
-      cacheKey: manifest.schemaCacheKey,
-      value: entry?.config
-    });
-    if (!validatedConfig.ok) {
-      record.status = "error";
-      record.error = `invalid config: ${validatedConfig.errors.join(", ")}`;
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
-      registry.diagnostics.push({
-        level: "error",
-        pluginId,
-        source: candidate.source,
-        message: record.error
-      });
-      continue;
-    }
-    if (mode === "validate") {
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
-      continue;
-    }
-    let moduleExport = null;
-    try {
-      moduleExport = jiti(candidate.source);
-    } catch (err) {
-      record.status = "error";
-      record.error = `failed to load plugin: ${String(err)}`;
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
-      registry.diagnostics.push({
-        level: "error",
-        pluginId,
-        source: candidate.source,
-        message: record.error
-      });
-      continue;
-    }
-    const resolved = resolvePluginModuleExport(moduleExport);
-    const definition = resolved.definition;
-    const register = resolved.register;
-    if (definition?.id && definition.id !== pluginId) {
-      registry.diagnostics.push({
-        level: "warn",
-        pluginId,
-        source: candidate.source,
-        message: `plugin id mismatch (manifest uses "${pluginId}", export uses "${definition.id}")`
-      });
-    }
-    record.name = definition?.name ?? record.name;
-    record.description = definition?.description ?? record.description;
-    record.version = definition?.version ?? record.version;
-    record.kind = definition?.kind ?? record.kind;
-    if (typeof register !== "function") {
-      record.status = "error";
-      record.error = "plugin export missing register/activate";
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
-      registry.diagnostics.push({
-        level: "error",
-        pluginId,
-        source: candidate.source,
-        message: record.error
-      });
-      continue;
-    }
-    const registerResult = registerPluginWithApi({
-      runtime: registerRuntime,
-      record,
-      pluginId,
-      source: candidate.source,
-      rootDir: candidate.rootDir,
-      register,
-      pluginConfig: validatedConfig.value
-    });
-    if (!registerResult.ok) {
-      record.status = "error";
-      record.error = registerResult.error;
-      registry.diagnostics.push({
-        level: "error",
-        pluginId,
-        source: candidate.source,
-        message: registerResult.error
-      });
-      registry.plugins.push(record);
-      seenIds.set(pluginId, candidate.origin);
-      continue;
-    }
-    registry.plugins.push(record);
-    seenIds.set(pluginId, candidate.origin);
-  }
-  return registry;
-}
-
-// src/plugins/status.ts
-import { getWorkspacePathFromConfig as getWorkspacePathFromConfig2 } from "@nextclaw/core";
-function buildPluginStatusReport(params) {
-  const workspaceDir = params.workspaceDir?.trim() || getWorkspacePathFromConfig2(params.config);
-  const registry = loadOpenClawPlugins({
-    config: params.config,
-    workspaceDir,
-    logger: params.logger,
-    reservedToolNames: params.reservedToolNames,
-    reservedChannelIds: params.reservedChannelIds,
-    reservedProviderIds: params.reservedProviderIds,
-    reservedEngineKinds: params.reservedEngineKinds,
-    reservedNcpAgentRuntimeKinds: params.reservedNcpAgentRuntimeKinds
-  });
-  return {
-    workspaceDir,
-    ...registry
-  };
-}
-
-// src/plugins/uninstall.ts
-import fs6 from "fs/promises";
-import { existsSync, statSync } from "fs";
-import path7 from "path";
-import { getWorkspacePathFromConfig as getWorkspacePathFromConfig3 } from "@nextclaw/core";
-function isLinkedPathInstall(record) {
-  if (!record || record.source !== "path") {
-    return false;
-  }
-  if (!record.sourcePath || !record.installPath) {
-    return true;
-  }
-  return path7.resolve(record.sourcePath) === path7.resolve(record.installPath);
-}
-function pushUniquePath(targets, candidate) {
-  if (!candidate) {
-    return;
-  }
-  const resolved = path7.resolve(candidate);
-  if (!targets.includes(resolved)) {
-    targets.push(resolved);
-  }
-}
-function resolveUninstallDirectoryTarget(params) {
-  if (!params.hasInstall) {
-    return null;
-  }
-  if (isLinkedPathInstall(params.installRecord)) {
-    return null;
-  }
-  let defaultPath;
-  try {
-    defaultPath = resolvePluginInstallDir(params.pluginId, params.extensionsDir);
-  } catch {
-    return null;
-  }
-  const configuredPath = params.installRecord?.installPath;
-  if (!configuredPath) {
-    return defaultPath;
-  }
-  if (path7.resolve(configuredPath) === path7.resolve(defaultPath)) {
-    return configuredPath;
-  }
-  return defaultPath;
-}
-function resolveUninstallDirectoryTargets(params) {
-  if (!params.hasInstall || isLinkedPathInstall(params.installRecord)) {
-    return [];
-  }
-  const targets = [];
-  pushUniquePath(
-    targets,
-    resolveUninstallDirectoryTarget({
-      pluginId: params.pluginId,
-      hasInstall: params.hasInstall,
-      installRecord: params.installRecord,
-      extensionsDir: params.extensionsDir
-    })
-  );
-  pushUniquePath(targets, params.installRecord?.installPath);
-  const workspaceDir = getWorkspacePathFromConfig3(params.config);
-  pushUniquePath(targets, path7.join(workspaceDir, ".nextclaw", "extensions", params.pluginId));
-  return targets;
-}
-function removePluginFromConfig(config, pluginId) {
-  const actions = {
-    entry: false,
-    install: false,
-    allowlist: false,
-    loadPath: false
-  };
-  const pluginsConfig = config.plugins ?? {};
-  let entries = pluginsConfig.entries;
-  if (entries && pluginId in entries) {
-    const rest = { ...entries };
-    delete rest[pluginId];
-    entries = Object.keys(rest).length > 0 ? rest : void 0;
-    actions.entry = true;
-  }
-  let installs = pluginsConfig.installs;
-  const installRecord = installs?.[pluginId];
-  if (installs && pluginId in installs) {
-    const rest = { ...installs };
-    delete rest[pluginId];
-    installs = Object.keys(rest).length > 0 ? rest : void 0;
-    actions.install = true;
-  }
-  let allow = pluginsConfig.allow;
-  if (Array.isArray(allow) && allow.includes(pluginId)) {
-    allow = allow.filter((id) => id !== pluginId);
-    if (allow.length === 0) {
-      allow = void 0;
-    }
-    actions.allowlist = true;
-  }
-  let load = pluginsConfig.load;
-  const configuredLoadPaths = Array.isArray(load?.paths) ? load.paths : [];
-  const nextLoadPaths = configuredLoadPaths.filter((entry) => !matchesPluginLoadPath(entry, pluginId));
-  if (nextLoadPaths.length !== configuredLoadPaths.length) {
-    load = nextLoadPaths.length > 0 ? { ...load, paths: nextLoadPaths } : void 0;
-    actions.loadPath = true;
-  } else if (installRecord?.source === "path" && installRecord.sourcePath && configuredLoadPaths.includes(installRecord.sourcePath)) {
-    const filteredLoadPaths = configuredLoadPaths.filter((entry) => entry !== installRecord.sourcePath);
-    load = filteredLoadPaths.length > 0 ? { ...load, paths: filteredLoadPaths } : void 0;
-    actions.loadPath = true;
-  }
-  const nextPlugins = {
-    ...pluginsConfig
-  };
-  if (entries === void 0) {
-    delete nextPlugins.entries;
-  } else {
-    nextPlugins.entries = entries;
-  }
-  if (installs === void 0) {
-    delete nextPlugins.installs;
-  } else {
-    nextPlugins.installs = installs;
-  }
-  if (allow === void 0) {
-    delete nextPlugins.allow;
-  } else {
-    nextPlugins.allow = allow;
-  }
-  if (load === void 0) {
-    delete nextPlugins.load;
-  } else {
-    nextPlugins.load = load;
-  }
-  return {
-    config: {
-      ...config,
-      plugins: nextPlugins
-    },
-    actions
-  };
-}
-function matchesPluginLoadPath(rawPath, pluginId) {
-  const normalizedPath = rawPath.trim();
-  if (!normalizedPath) {
-    return false;
-  }
-  const resolvedPath = path7.resolve(normalizedPath);
-  if (!existsSync(resolvedPath)) {
-    return false;
-  }
-  const candidateRoot = (() => {
-    try {
-      return statSync(resolvedPath).isDirectory() ? resolvedPath : path7.dirname(resolvedPath);
-    } catch {
-      return null;
-    }
-  })();
-  if (!candidateRoot) {
-    return false;
-  }
-  const manifest = loadPluginManifest(candidateRoot);
-  return manifest.ok && manifest.manifest.id === pluginId;
-}
-async function uninstallPlugin(params) {
-  const { config, pluginId, deleteFiles = true, extensionsDir } = params;
-  const hasEntry = pluginId in (config.plugins.entries ?? {});
-  const hasInstall = pluginId in (config.plugins.installs ?? {});
-  if (!hasEntry && !hasInstall) {
-    return { ok: false, error: `Plugin not found: ${pluginId}` };
-  }
-  const installRecord = config.plugins.installs?.[pluginId];
-  const isLinked = isLinkedPathInstall(installRecord);
-  const { config: nextConfig, actions: configActions } = removePluginFromConfig(config, pluginId);
-  const actions = {
-    ...configActions,
-    directory: false
-  };
-  const warnings = [];
-  const deleteTargets = deleteFiles && !isLinked ? resolveUninstallDirectoryTargets({
-    config,
-    pluginId,
-    hasInstall,
-    installRecord,
-    extensionsDir
-  }) : [];
-  for (const deleteTarget of deleteTargets) {
-    const existed = await fs6.access(deleteTarget).then(() => true).catch(() => false);
-    try {
-      await fs6.rm(deleteTarget, { recursive: true, force: true });
-      actions.directory = actions.directory || existed;
-    } catch (error) {
-      warnings.push(
-        `Failed to remove plugin directory ${deleteTarget}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return {
-    ok: true,
-    config: nextConfig,
-    pluginId,
-    actions,
-    warnings
-  };
-}
-export {
-  DEFAULT_ACCOUNT_ID,
-  PLUGIN_MANIFEST_FILENAME,
-  PLUGIN_MANIFEST_FILENAMES,
-  __nextclawPluginSdkCompat,
-  addPluginLoadPath,
-  buildChannelConfigSchema,
-  buildOauthProviderAuthResult,
-  buildPluginLoaderAliases,
-  buildPluginStatusReport,
-  createNextclawBuiltinChannelPlugin,
-  createPluginRegisterRuntime,
-  createPluginRuntime,
-  disablePluginInConfig,
-  discoverOpenClawPlugins,
-  emptyPluginConfigSchema,
-  enablePluginInConfig,
-  getPackageManifestMetadata,
-  getPluginChannelBindings,
-  getPluginUiMetadataFromRegistry,
-  installPluginFromArchive,
-  installPluginFromDir,
-  installPluginFromFile,
-  installPluginFromNpmSpec,
-  installPluginFromPath,
-  loadOpenClawPlugins,
-  loadPluginManifest,
-  loadPluginManifestRegistry,
-  loadPluginUiMetadata,
-  normalizeAccountId,
-  normalizePluginHttpPath,
-  normalizePluginsConfig,
-  recordPluginInstall,
-  registerPluginWithApi,
-  removePluginFromConfig,
-  resolveEnableState,
-  resolvePluginChannelMessageToolHints,
-  resolvePluginInstallDir,
-  resolvePluginManifestPath,
-  resolveUninstallDirectoryTarget,
-  resolveUninstallDirectoryTargets,
-  setPluginRuntimeBridge,
-  sleep,
-  startPluginChannelGateways,
-  stopPluginChannelGateways,
-  toPluginUiMetadata,
-  uninstallPlugin,
-  validateJsonSchemaValue
-};