@nextclaw/openclaw-compat 0.3.6 → 0.3.8

package/dist/index.js

@@ -0,0 +1,2539 @@
+// 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 collectConfiguredInstallPaths(config) {
+  if (!config?.plugins?.installs) {
+    return [];
+  }
+  const paths = [];
+  for (const installRecord of Object.values(config.plugins.installs)) {
+    if (!installRecord || typeof installRecord !== "object") {
+      continue;
+    }
+    const installPath = typeof installRecord.installPath === "string" ? installRecord.installPath.trim() : "";
+    if (!installPath || paths.includes(installPath)) {
+      continue;
+    }
+    paths.push(installPath);
+  }
+  return paths;
+}
+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 configuredLoadPaths = params.extraPaths ?? params.config?.plugins?.load?.paths ?? [];
+  const loadPaths = [...configuredLoadPaths, ...collectConfiguredInstallPaths(params.config)];
+  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 { 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/plugin-loader-jiti.ts
+import createJitiImport from "jiti";
+var createJiti = createJitiImport;
+function createPluginJiti(aliases) {
+  return createJiti(import.meta.url, {
+    interopDefault: true,
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
+    alias: aliases,
+    // Plugin install/upgrade is expected to hot-apply at runtime. Disable
+    // Jiti's persistent/native require cache so a reload always sees the
+    // latest plugin code on disk instead of reusing a stale in-memory module.
+    requireCache: false,
+    cache: false
+  });
+}
+
+// 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,
+    describeSessionType: params.registration.describeSessionType,
+    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 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 = createPluginJiti(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
+};