@nextclaw/openclaw-compat 0.1.1

package/dist/index.js

@@ -0,0 +1,1835 @@
+// src/plugin-sdk/index.ts
+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;
+}
+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/discovery.ts
+import fs2 from "fs";
+import path2 from "path";
+import { homedir } from "os";
+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, ".openclaw", "extensions"),
+      origin: "workspace",
+      workspaceDir,
+      candidates,
+      diagnostics,
+      seen
+    });
+  }
+  discoverInDirectory({
+    dir: path2.join(getDataPath(), "extensions"),
+    origin: "global",
+    candidates,
+    diagnostics,
+    seen
+  });
+  discoverInDirectory({
+    dir: path2.join(homedir(), ".openclaw", "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 });
+  for (const extensionPath of extensions) {
+    const resolved = path3.resolve(targetDir, extensionPath);
+    if (!resolved.startsWith(path3.resolve(targetDir) + path3.sep) && resolved !== path3.resolve(targetDir)) {
+      return { ok: false, error: `extension entry escapes plugin directory: ${extensionPath}` };
+    }
+    if (!await exists(resolved)) {
+      logger.warn?.(`extension entry not found: ${extensionPath}`);
+    }
+  }
+  try {
+    await installDependenciesIfNeeded(targetDir, packageManifest, logger);
+  } catch (err) {
+    return { ok: false, error: `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 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 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 path4 from "path";
+import { fileURLToPath } from "url";
+import createJitiImport from "jiti";
+import { getWorkspacePathFromConfig } from "@nextclaw/core";
+import { expandHome as expandHome2 } from "@nextclaw/core";
+
+// 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/runtime.ts
+import { getPackageVersion } from "@nextclaw/core";
+import { MemoryGetTool, MemorySearchTool } from "@nextclaw/core";
+function toPluginTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    execute: (params) => tool.execute(params)
+  };
+}
+function createPluginRuntime(params) {
+  return {
+    version: getPackageVersion(),
+    tools: {
+      createMemorySearchTool: () => toPluginTool(new MemorySearchTool(params.workspace)),
+      createMemoryGetTool: () => toPluginTool(new MemoryGetTool(params.workspace))
+    }
+  };
+}
+
+// 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 path6 = error.instancePath?.replace(/^\//, "").replace(/\//g, ".") || "<root>";
+    const message = error.message ?? "invalid";
+    return `${path6}: ${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/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)
+};
+function resolvePluginSdkAliasFile(params) {
+  try {
+    const modulePath = fileURLToPath(import.meta.url);
+    const isProduction = process.env.NODE_ENV === "production";
+    let cursor = path4.dirname(modulePath);
+    for (let i = 0; i < 6; i += 1) {
+      const srcCandidate = path4.join(cursor, "src", "plugin-sdk", params.srcFile);
+      const distCandidate = path4.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 = path4.dirname(cursor);
+      if (parent === cursor) {
+        break;
+      }
+      cursor = parent;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePluginSdkAlias() {
+  return resolvePluginSdkAliasFile({ srcFile: "index.ts", distFile: "index.js" });
+}
+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 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 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: [],
+    configSchema: params.configSchema,
+    configUiHints: params.configUiHints,
+    configJsonSchema: params.configJsonSchema
+  };
+}
+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 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 validatePluginConfig(params) {
+  if (!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 };
+}
+function loadOpenClawPlugins(options) {
+  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: [],
+    diagnostics: [],
+    resolvedTools: []
+  };
+  const toolNameOwners = /* @__PURE__ */ new Map();
+  const channelIdOwners = /* @__PURE__ */ new Map();
+  const providerIdOwners = /* @__PURE__ */ new Map();
+  const resolvedToolNames = /* @__PURE__ */ new Set();
+  const reservedToolNames = new Set(options.reservedToolNames ?? []);
+  const reservedChannelIds = new Set(options.reservedChannelIds ?? []);
+  const reservedProviderIds = new Set(options.reservedProviderIds ?? []);
+  const discovery = discoverOpenClawPlugins({
+    config: options.config,
+    workspaceDir,
+    extraPaths: normalized.loadPaths
+  });
+  const manifestRegistry = loadPluginManifestRegistry({
+    config: options.config,
+    workspaceDir,
+    candidates: discovery.candidates,
+    diagnostics: discovery.diagnostics
+  });
+  registry.diagnostics.push(...manifestRegistry.diagnostics);
+  const manifestByRoot = new Map(manifestRegistry.plugins.map((entry) => [entry.rootDir, entry]));
+  const seenIds = /* @__PURE__ */ new Map();
+  const pluginSdkAlias = resolvePluginSdkAlias();
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
+    ...pluginSdkAlias ? {
+      alias: {
+        "openclaw/plugin-sdk": pluginSdkAlias
+      }
+    } : {}
+  });
+  for (const candidate of discovery.candidates) {
+    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 pluginRuntime = createPluginRuntime({ workspace: workspaceDir, config: options.config });
+    const pluginLogger = buildPluginLogger(logger, pluginId);
+    const pushUnsupported = (capability) => {
+      registry.diagnostics.push({
+        level: "warn",
+        pluginId,
+        source: candidate.source,
+        message: `${capability} is not supported by nextclaw compat layer yet`
+      });
+      pluginLogger.warn(`${capability} is ignored (not supported yet)`);
+    };
+    const api = {
+      id: pluginId,
+      name: record.name,
+      version: record.version,
+      description: record.description,
+      source: candidate.source,
+      config: options.config,
+      pluginConfig: validatedConfig.value,
+      runtime: pluginRuntime,
+      logger: pluginLogger,
+      registerTool: (tool, opts) => {
+        const declaredNames = opts && Array.isArray(opts.names) ? opts.names : [];
+        const names = [...declaredNames, ...opts && opts.name ? [opts.name] : []];
+        if (typeof tool !== "function" && typeof tool.name === "string") {
+          names.push(tool.name);
+        }
+        const uniqueNames = Array.from(new Set(names.map((name) => name.trim()).filter(Boolean)));
+        const acceptedNames = ensureUniqueNames({
+          names: uniqueNames,
+          pluginId,
+          diagnostics: registry.diagnostics,
+          source: candidate.source,
+          owners: toolNameOwners,
+          reserved: reservedToolNames,
+          kind: "tool"
+        });
+        if (acceptedNames.length === 0) {
+          registry.diagnostics.push({
+            level: "warn",
+            pluginId,
+            source: candidate.source,
+            message: "tool registration skipped: no available tool names"
+          });
+          return;
+        }
+        const factory = typeof tool === "function" ? tool : (_ctx) => tool;
+        registry.tools.push({
+          pluginId,
+          factory,
+          names: acceptedNames,
+          optional: opts?.optional === true,
+          source: candidate.source
+        });
+        record.toolNames.push(...acceptedNames);
+        try {
+          const previewTools = normalizeToolList(
+            factory({
+              config: options.config,
+              workspaceDir,
+              sandboxed: false
+            })
+          );
+          const byName = new Map(previewTools.map((entry2) => [entry2.name, entry2]));
+          for (const name of acceptedNames) {
+            const resolvedTool = byName.get(name);
+            if (!resolvedTool || resolvedToolNames.has(resolvedTool.name)) {
+              continue;
+            }
+            resolvedToolNames.add(resolvedTool.name);
+            registry.resolvedTools.push(resolvedTool);
+          }
+        } catch (err) {
+          registry.diagnostics.push({
+            level: "warn",
+            pluginId,
+            source: candidate.source,
+            message: `tool preview failed: ${String(err)}`
+          });
+        }
+      },
+      registerChannel: (registration) => {
+        const normalizedChannel = registration && typeof registration === "object" && "plugin" in registration ? registration.plugin : registration;
+        if (!normalizedChannel || typeof normalizedChannel !== "object") {
+          registry.diagnostics.push({
+            level: "error",
+            pluginId,
+            source: candidate.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,
+          diagnostics: registry.diagnostics,
+          source: candidate.source,
+          owners: channelIdOwners,
+          reserved: reservedChannelIds,
+          kind: "channel"
+        });
+        if (accepted.length === 0) {
+          return;
+        }
+        registry.channels.push({
+          pluginId,
+          channel: normalizedChannel,
+          source: candidate.source
+        });
+        record.channelIds.push(accepted[0]);
+      },
+      registerProvider: (provider) => {
+        const accepted = ensureUniqueNames({
+          names: [provider.id],
+          pluginId,
+          diagnostics: registry.diagnostics,
+          source: candidate.source,
+          owners: providerIdOwners,
+          reserved: reservedProviderIds,
+          kind: "provider"
+        });
+        if (accepted.length === 0) {
+          return;
+        }
+        registry.providers.push({
+          pluginId,
+          provider,
+          source: candidate.source
+        });
+        record.providerIds.push(accepted[0]);
+      },
+      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 candidate.rootDir;
+        }
+        if (path4.isAbsolute(trimmed)) {
+          return path4.resolve(expandHome2(trimmed));
+        }
+        return path4.resolve(candidate.rootDir, trimmed);
+      }
+    };
+    try {
+      const result = register(api);
+      if (result && typeof result === "object" && "then" in result) {
+        registry.diagnostics.push({
+          level: "warn",
+          pluginId,
+          source: candidate.source,
+          message: "plugin register returned a promise; async registration is ignored"
+        });
+      }
+      registry.plugins.push(record);
+      seenIds.set(pluginId, candidate.origin);
+    } catch (err) {
+      record.status = "error";
+      record.error = `plugin failed during register: ${String(err)}`;
+      registry.plugins.push(record);
+      seenIds.set(pluginId, candidate.origin);
+      registry.diagnostics.push({
+        level: "error",
+        pluginId,
+        source: candidate.source,
+        message: record.error
+      });
+    }
+  }
+  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
+  });
+  return {
+    workspaceDir,
+    ...registry
+  };
+}
+
+// src/plugins/uninstall.ts
+import fs6 from "fs/promises";
+import path5 from "path";
+function resolveUninstallDirectoryTarget(params) {
+  if (!params.hasInstall) {
+    return null;
+  }
+  if (params.installRecord?.source === "path") {
+    return null;
+  }
+  let defaultPath;
+  try {
+    defaultPath = resolvePluginInstallDir(params.pluginId, params.extensionsDir);
+  } catch {
+    return null;
+  }
+  const configuredPath = params.installRecord?.installPath;
+  if (!configuredPath) {
+    return defaultPath;
+  }
+  if (path5.resolve(configuredPath) === path5.resolve(defaultPath)) {
+    return configuredPath;
+  }
+  return defaultPath;
+}
+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;
+  if (installRecord?.source === "path" && installRecord.sourcePath) {
+    const sourcePath = installRecord.sourcePath;
+    const loadPaths = load?.paths;
+    if (Array.isArray(loadPaths) && loadPaths.includes(sourcePath)) {
+      const nextLoadPaths = loadPaths.filter((entry) => entry !== sourcePath);
+      load = nextLoadPaths.length > 0 ? { ...load, paths: nextLoadPaths } : 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
+  };
+}
+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 = installRecord?.source === "path";
+  const { config: nextConfig, actions: configActions } = removePluginFromConfig(config, pluginId);
+  const actions = {
+    ...configActions,
+    directory: false
+  };
+  const warnings = [];
+  const deleteTarget = deleteFiles && !isLinked ? resolveUninstallDirectoryTarget({
+    pluginId,
+    hasInstall,
+    installRecord,
+    extensionsDir
+  }) : null;
+  if (deleteTarget) {
+    const existed = await fs6.access(deleteTarget).then(() => true).catch(() => false) ?? false;
+    try {
+      await fs6.rm(deleteTarget, { recursive: true, force: true });
+      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,
+  buildPluginStatusReport,
+  createPluginRuntime,
+  disablePluginInConfig,
+  discoverOpenClawPlugins,
+  emptyPluginConfigSchema,
+  enablePluginInConfig,
+  getPackageManifestMetadata,
+  installPluginFromArchive,
+  installPluginFromDir,
+  installPluginFromFile,
+  installPluginFromNpmSpec,
+  installPluginFromPath,
+  loadOpenClawPlugins,
+  loadPluginManifest,
+  loadPluginManifestRegistry,
+  loadPluginUiMetadata,
+  normalizeAccountId,
+  normalizePluginHttpPath,
+  normalizePluginsConfig,
+  recordPluginInstall,
+  removePluginFromConfig,
+  resolveEnableState,
+  resolvePluginInstallDir,
+  resolvePluginManifestPath,
+  resolveUninstallDirectoryTarget,
+  sleep,
+  toPluginUiMetadata,
+  uninstallPlugin,
+  validateJsonSchemaValue
+};