@dexto/agent-management 1.5.6 → 1.5.8

package/dist/plugins/uninstall-plugin.cjs

@@ -0,0 +1,133 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var uninstall_plugin_exports = {};
+__export(uninstall_plugin_exports, {
+  uninstallPlugin: () => uninstallPlugin
+});
+module.exports = __toCommonJS(uninstall_plugin_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_install_plugin = require("./install-plugin.js");
+var import_errors = require("./errors.js");
+function findPluginInstallation(pluginName, projectPath) {
+  const installed = (0, import_install_plugin.loadDextoInstalledPlugins)();
+  const normalizedName = pluginName.toLowerCase();
+  const currentProjectPath = projectPath || process.cwd();
+  if (installed.plugins[pluginName]) {
+    const installations = installed.plugins[pluginName];
+    for (const entry of installations) {
+      if ((entry.scope === "project" || entry.scope === "local") && entry.projectPath) {
+        const normalizedInstallProject = path.resolve(entry.projectPath).toLowerCase();
+        const normalizedCurrentProject = path.resolve(currentProjectPath).toLowerCase();
+        if (normalizedInstallProject === normalizedCurrentProject) {
+          return { entry, pluginId: pluginName };
+        }
+        continue;
+      }
+      return { entry, pluginId: pluginName };
+    }
+  }
+  for (const [pluginId, installations] of Object.entries(installed.plugins)) {
+    for (const entry of installations) {
+      const manifestPath = path.join(entry.installPath, ".claude-plugin", "plugin.json");
+      if (!(0, import_fs.existsSync)(manifestPath)) continue;
+      try {
+        const content = (0, import_fs.readFileSync)(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.name?.toLowerCase() !== normalizedName) continue;
+        if ((entry.scope === "project" || entry.scope === "local") && entry.projectPath) {
+          const normalizedInstallProject = path.resolve(entry.projectPath).toLowerCase();
+          const normalizedCurrentProject = path.resolve(currentProjectPath).toLowerCase();
+          if (normalizedInstallProject === normalizedCurrentProject) {
+            return { entry, pluginId };
+          }
+          continue;
+        }
+        return { entry, pluginId };
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+async function uninstallPlugin(pluginName, options) {
+  const { projectPath } = options || {};
+  const atIndex = pluginName.lastIndexOf("@");
+  const SEMVER_SUFFIX = /^(?:v)?\d+\.\d+\.\d+(?:-[\w.-]+)?$/;
+  const nameWithoutVersion = atIndex > 0 && SEMVER_SUFFIX.test(pluginName.slice(atIndex + 1)) ? pluginName.slice(0, atIndex) : pluginName;
+  const found = findPluginInstallation(nameWithoutVersion, projectPath);
+  if (!found) {
+    throw import_errors.PluginError.uninstallNotFound(nameWithoutVersion);
+  }
+  const { entry, pluginId } = found;
+  let removedPath;
+  const shouldDeleteFiles = !entry.isLocal;
+  if (shouldDeleteFiles) {
+    try {
+      (0, import_fs.rmSync)(entry.installPath, { recursive: true, force: true });
+      removedPath = entry.installPath;
+    } catch (error) {
+      throw import_errors.PluginError.uninstallDeleteFailed(
+        entry.installPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  } else {
+    removedPath = entry.installPath;
+  }
+  const installed = (0, import_install_plugin.loadDextoInstalledPlugins)();
+  const currentProjectPath = projectPath || process.cwd();
+  if (installed.plugins[pluginId]) {
+    installed.plugins[pluginId] = installed.plugins[pluginId].filter((e) => {
+      if (e.installPath !== entry.installPath) return true;
+      if (e.scope === entry.scope) {
+        if ((e.scope === "project" || e.scope === "local") && e.projectPath) {
+          const normalizedEntryProject = path.resolve(e.projectPath).toLowerCase();
+          const normalizedCurrentProject = path.resolve(currentProjectPath).toLowerCase();
+          return normalizedEntryProject !== normalizedCurrentProject;
+        }
+        return false;
+      }
+      return true;
+    });
+    if (installed.plugins[pluginId].length === 0) {
+      delete installed.plugins[pluginId];
+    }
+  }
+  (0, import_install_plugin.saveDextoInstalledPlugins)(installed);
+  return {
+    success: true,
+    removedPath
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uninstallPlugin
+});

package/dist/plugins/uninstall-plugin.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Plugin Uninstallation
+ *
+ * Uninstalls plugins from Dexto's plugin directory.
+ * Removes plugin files and updates installed_plugins.json.
+ */
+import type { PluginUninstallResult } from './types.js';
+/**
+ * Options for plugin uninstallation
+ */
+export interface UninstallPluginOptions {
+    /** Project path for filtering project-scoped plugins */
+    projectPath?: string;
+}
+/**
+ * Uninstalls a plugin by name.
+ * Accepts both "name" and "name@version" formats.
+ *
+ * @param pluginName Plugin name to uninstall (with optional @version suffix)
+ * @param options Uninstallation options
+ * @returns Uninstallation result with success status
+ */
+export declare function uninstallPlugin(pluginName: string, options?: UninstallPluginOptions): Promise<PluginUninstallResult>;
+//# sourceMappingURL=uninstall-plugin.d.ts.map

package/dist/plugins/uninstall-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uninstall-plugin.d.ts","sourceRoot":"","sources":["../../src/plugins/uninstall-plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,qBAAqB,EAAwB,MAAM,YAAY,CAAC;AAE9E;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAmED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACjC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,sBAAsB,GACjC,OAAO,CAAC,qBAAqB,CAAC,CA2EhC"}

package/dist/plugins/uninstall-plugin.js

@@ -0,0 +1,99 @@
+import * as path from "path";
+import { existsSync, readFileSync, rmSync } from "fs";
+import { loadDextoInstalledPlugins, saveDextoInstalledPlugins } from "./install-plugin.js";
+import { PluginError } from "./errors.js";
+function findPluginInstallation(pluginName, projectPath) {
+  const installed = loadDextoInstalledPlugins();
+  const normalizedName = pluginName.toLowerCase();
+  const currentProjectPath = projectPath || process.cwd();
+  if (installed.plugins[pluginName]) {
+    const installations = installed.plugins[pluginName];
+    for (const entry of installations) {
+      if ((entry.scope === "project" || entry.scope === "local") && entry.projectPath) {
+        const normalizedInstallProject = path.resolve(entry.projectPath).toLowerCase();
+        const normalizedCurrentProject = path.resolve(currentProjectPath).toLowerCase();
+        if (normalizedInstallProject === normalizedCurrentProject) {
+          return { entry, pluginId: pluginName };
+        }
+        continue;
+      }
+      return { entry, pluginId: pluginName };
+    }
+  }
+  for (const [pluginId, installations] of Object.entries(installed.plugins)) {
+    for (const entry of installations) {
+      const manifestPath = path.join(entry.installPath, ".claude-plugin", "plugin.json");
+      if (!existsSync(manifestPath)) continue;
+      try {
+        const content = readFileSync(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.name?.toLowerCase() !== normalizedName) continue;
+        if ((entry.scope === "project" || entry.scope === "local") && entry.projectPath) {
+          const normalizedInstallProject = path.resolve(entry.projectPath).toLowerCase();
+          const normalizedCurrentProject = path.resolve(currentProjectPath).toLowerCase();
+          if (normalizedInstallProject === normalizedCurrentProject) {
+            return { entry, pluginId };
+          }
+          continue;
+        }
+        return { entry, pluginId };
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+async function uninstallPlugin(pluginName, options) {
+  const { projectPath } = options || {};
+  const atIndex = pluginName.lastIndexOf("@");
+  const SEMVER_SUFFIX = /^(?:v)?\d+\.\d+\.\d+(?:-[\w.-]+)?$/;
+  const nameWithoutVersion = atIndex > 0 && SEMVER_SUFFIX.test(pluginName.slice(atIndex + 1)) ? pluginName.slice(0, atIndex) : pluginName;
+  const found = findPluginInstallation(nameWithoutVersion, projectPath);
+  if (!found) {
+    throw PluginError.uninstallNotFound(nameWithoutVersion);
+  }
+  const { entry, pluginId } = found;
+  let removedPath;
+  const shouldDeleteFiles = !entry.isLocal;
+  if (shouldDeleteFiles) {
+    try {
+      rmSync(entry.installPath, { recursive: true, force: true });
+      removedPath = entry.installPath;
+    } catch (error) {
+      throw PluginError.uninstallDeleteFailed(
+        entry.installPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  } else {
+    removedPath = entry.installPath;
+  }
+  const installed = loadDextoInstalledPlugins();
+  const currentProjectPath = projectPath || process.cwd();
+  if (installed.plugins[pluginId]) {
+    installed.plugins[pluginId] = installed.plugins[pluginId].filter((e) => {
+      if (e.installPath !== entry.installPath) return true;
+      if (e.scope === entry.scope) {
+        if ((e.scope === "project" || e.scope === "local") && e.projectPath) {
+          const normalizedEntryProject = path.resolve(e.projectPath).toLowerCase();
+          const normalizedCurrentProject = path.resolve(currentProjectPath).toLowerCase();
+          return normalizedEntryProject !== normalizedCurrentProject;
+        }
+        return false;
+      }
+      return true;
+    });
+    if (installed.plugins[pluginId].length === 0) {
+      delete installed.plugins[pluginId];
+    }
+  }
+  saveDextoInstalledPlugins(installed);
+  return {
+    success: true,
+    removedPath
+  };
+}
+export {
+  uninstallPlugin
+};

package/dist/plugins/validate-plugin.cjs

@@ -0,0 +1,180 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_plugin_exports = {};
+__export(validate_plugin_exports, {
+  tryLoadManifest: () => tryLoadManifest,
+  validatePluginDirectory: () => validatePluginDirectory
+});
+module.exports = __toCommonJS(validate_plugin_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_schemas = require("./schemas.js");
+function validatePluginDirectory(pluginPath) {
+  const errors = [];
+  const warnings = [];
+  let manifest;
+  let format;
+  const absolutePath = path.isAbsolute(pluginPath) ? pluginPath : path.resolve(pluginPath);
+  if (!(0, import_fs.existsSync)(absolutePath)) {
+    errors.push(`Directory does not exist: ${absolutePath}`);
+    return { valid: false, errors, warnings };
+  }
+  const dextoPluginDir = path.join(absolutePath, ".dexto-plugin");
+  const claudePluginDir = path.join(absolutePath, ".claude-plugin");
+  let manifestPath;
+  if ((0, import_fs.existsSync)(dextoPluginDir)) {
+    manifestPath = path.join(dextoPluginDir, "plugin.json");
+    format = "dexto";
+  } else if ((0, import_fs.existsSync)(claudePluginDir)) {
+    manifestPath = path.join(claudePluginDir, "plugin.json");
+    format = "claude-code";
+  } else {
+    errors.push("Missing .dexto-plugin or .claude-plugin directory");
+    return { valid: false, errors, warnings };
+  }
+  if (!(0, import_fs.existsSync)(manifestPath)) {
+    errors.push(
+      `Missing ${format === "dexto" ? ".dexto-plugin" : ".claude-plugin"}/plugin.json`
+    );
+    return { valid: false, errors, warnings };
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(manifestPath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (parseError) {
+      errors.push(
+        `Invalid JSON in plugin.json: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+      );
+      return { valid: false, errors, warnings };
+    }
+    const schema = format === "dexto" ? import_schemas.DextoPluginManifestSchema : import_schemas.PluginManifestSchema;
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`);
+      errors.push(`Schema validation failed: ${issues.join("; ")}`);
+      return { valid: false, errors, warnings };
+    }
+    manifest = result.data;
+  } catch (error) {
+    errors.push(
+      `Failed to read plugin.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return { valid: false, errors, warnings };
+  }
+  const hasCommands = checkDirectoryHasFiles(path.join(absolutePath, "commands"), ".md");
+  const hasSkills = checkDirectoryHasSkills(path.join(absolutePath, "skills"));
+  if (!hasCommands && !hasSkills) {
+    warnings.push("Plugin has no commands or skills");
+  }
+  if ((0, import_fs.existsSync)(path.join(absolutePath, "hooks"))) {
+    warnings.push("hooks/ directory found - hooks are not supported (security risk)");
+  }
+  if ((0, import_fs.existsSync)(path.join(absolutePath, ".lsp.json"))) {
+    warnings.push(".lsp.json found - LSP configuration is not supported");
+  }
+  const mcpPath = path.join(absolutePath, ".mcp.json");
+  if ((0, import_fs.existsSync)(mcpPath)) {
+    try {
+      const mcpContent = (0, import_fs.readFileSync)(mcpPath, "utf-8");
+      JSON.parse(mcpContent);
+    } catch {
+      warnings.push(".mcp.json exists but contains invalid JSON");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    manifest,
+    format,
+    errors,
+    warnings
+  };
+}
+function checkDirectoryHasFiles(dirPath, extension) {
+  if (!(0, import_fs.existsSync)(dirPath)) {
+    return false;
+  }
+  try {
+    const entries = (0, import_fs.readdirSync)(dirPath, { withFileTypes: true });
+    return entries.some((entry) => entry.isFile() && entry.name.endsWith(extension));
+  } catch {
+    return false;
+  }
+}
+function checkDirectoryHasSkills(skillsDir) {
+  if (!(0, import_fs.existsSync)(skillsDir)) {
+    return false;
+  }
+  try {
+    const entries = (0, import_fs.readdirSync)(skillsDir, { withFileTypes: true });
+    return entries.some((entry) => {
+      if (!entry.isDirectory()) return false;
+      const skillMdPath = path.join(skillsDir, entry.name, "SKILL.md");
+      return (0, import_fs.existsSync)(skillMdPath);
+    });
+  } catch {
+    return false;
+  }
+}
+function tryLoadManifest(pluginPath, returnFormat) {
+  const dextoManifestPath = path.join(pluginPath, ".dexto-plugin", "plugin.json");
+  const claudeManifestPath = path.join(pluginPath, ".claude-plugin", "plugin.json");
+  let manifestPath;
+  let format;
+  if ((0, import_fs.existsSync)(dextoManifestPath)) {
+    manifestPath = dextoManifestPath;
+    format = "dexto";
+  } else if ((0, import_fs.existsSync)(claudeManifestPath)) {
+    manifestPath = claudeManifestPath;
+    format = "claude-code";
+  } else {
+    return null;
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(manifestPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const schema = format === "dexto" ? import_schemas.DextoPluginManifestSchema : import_schemas.PluginManifestSchema;
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      return null;
+    }
+    if (returnFormat) {
+      return { manifest: result.data, format };
+    }
+    return result.data;
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tryLoadManifest,
+  validatePluginDirectory
+});

package/dist/plugins/validate-plugin.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Plugin Validation
+ *
+ * Validates plugin directory structure and manifest.
+ * Checks for required files, valid JSON, and schema compliance.
+ *
+ * Supports two plugin formats:
+ * - .claude-plugin/plugin.json: Claude Code compatible format
+ * - .dexto-plugin/plugin.json: Dexto-native format with extended features (preferred)
+ */
+import type { PluginValidationResult, PluginManifest, DextoPluginManifest, PluginFormat } from './types.js';
+/**
+ * Extended validation result with plugin format
+ */
+export interface ExtendedPluginValidationResult extends PluginValidationResult {
+    /** Plugin format detected */
+    format?: PluginFormat;
+}
+/**
+ * Validates a plugin directory structure and manifest.
+ *
+ * Checks:
+ * 1. Directory exists
+ * 2. .dexto-plugin/plugin.json OR .claude-plugin/plugin.json exists (Dexto format preferred)
+ * 3. plugin.json is valid JSON
+ * 4. plugin.json matches schema (name is required)
+ * 5. At least one command or skill exists (warning if none)
+ *
+ * @param pluginPath Absolute or relative path to plugin directory
+ * @returns Validation result with manifest (if valid), errors, and warnings
+ */
+export declare function validatePluginDirectory(pluginPath: string): ExtendedPluginValidationResult;
+/**
+ * Result of manifest loading with format information
+ */
+export interface LoadedManifestResult {
+    manifest: PluginManifest | DextoPluginManifest;
+    format: PluginFormat;
+}
+/**
+ * Attempts to load and validate a plugin manifest from a directory.
+ * Returns null if the manifest doesn't exist, is invalid JSON, or fails schema validation.
+ *
+ * Checks for .dexto-plugin first (preferred), then falls back to .claude-plugin.
+ *
+ * This is a shared utility used by discover-plugins, list-plugins, and import-plugin.
+ *
+ * @param pluginPath Absolute path to the plugin directory
+ * @returns Validated manifest with format or null if not a valid plugin
+ */
+export declare function tryLoadManifest(pluginPath: string): PluginManifest | null;
+export declare function tryLoadManifest(pluginPath: string, returnFormat: true): LoadedManifestResult | null;
+//# sourceMappingURL=validate-plugin.d.ts.map

package/dist/plugins/validate-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-plugin.d.ts","sourceRoot":"","sources":["../../src/plugins/validate-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,KAAK,EACR,sBAAsB,EACtB,cAAc,EACd,mBAAmB,EACnB,YAAY,EACf,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,8BAA+B,SAAQ,sBAAsB;IAC1E,6BAA6B;IAC7B,MAAM,CAAC,EAAE,YAAY,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,8BAA8B,CAyG1F;AAuCD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,cAAc,GAAG,mBAAmB,CAAC;IAC/C,MAAM,EAAE,YAAY,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAAC;AAC3E,wBAAgB,eAAe,CAC3B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,IAAI,GACnB,oBAAoB,GAAG,IAAI,CAAC"}

package/dist/plugins/validate-plugin.js

@@ -0,0 +1,145 @@
+import * as path from "path";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { PluginManifestSchema, DextoPluginManifestSchema } from "./schemas.js";
+function validatePluginDirectory(pluginPath) {
+  const errors = [];
+  const warnings = [];
+  let manifest;
+  let format;
+  const absolutePath = path.isAbsolute(pluginPath) ? pluginPath : path.resolve(pluginPath);
+  if (!existsSync(absolutePath)) {
+    errors.push(`Directory does not exist: ${absolutePath}`);
+    return { valid: false, errors, warnings };
+  }
+  const dextoPluginDir = path.join(absolutePath, ".dexto-plugin");
+  const claudePluginDir = path.join(absolutePath, ".claude-plugin");
+  let manifestPath;
+  if (existsSync(dextoPluginDir)) {
+    manifestPath = path.join(dextoPluginDir, "plugin.json");
+    format = "dexto";
+  } else if (existsSync(claudePluginDir)) {
+    manifestPath = path.join(claudePluginDir, "plugin.json");
+    format = "claude-code";
+  } else {
+    errors.push("Missing .dexto-plugin or .claude-plugin directory");
+    return { valid: false, errors, warnings };
+  }
+  if (!existsSync(manifestPath)) {
+    errors.push(
+      `Missing ${format === "dexto" ? ".dexto-plugin" : ".claude-plugin"}/plugin.json`
+    );
+    return { valid: false, errors, warnings };
+  }
+  try {
+    const content = readFileSync(manifestPath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (parseError) {
+      errors.push(
+        `Invalid JSON in plugin.json: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+      );
+      return { valid: false, errors, warnings };
+    }
+    const schema = format === "dexto" ? DextoPluginManifestSchema : PluginManifestSchema;
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`);
+      errors.push(`Schema validation failed: ${issues.join("; ")}`);
+      return { valid: false, errors, warnings };
+    }
+    manifest = result.data;
+  } catch (error) {
+    errors.push(
+      `Failed to read plugin.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return { valid: false, errors, warnings };
+  }
+  const hasCommands = checkDirectoryHasFiles(path.join(absolutePath, "commands"), ".md");
+  const hasSkills = checkDirectoryHasSkills(path.join(absolutePath, "skills"));
+  if (!hasCommands && !hasSkills) {
+    warnings.push("Plugin has no commands or skills");
+  }
+  if (existsSync(path.join(absolutePath, "hooks"))) {
+    warnings.push("hooks/ directory found - hooks are not supported (security risk)");
+  }
+  if (existsSync(path.join(absolutePath, ".lsp.json"))) {
+    warnings.push(".lsp.json found - LSP configuration is not supported");
+  }
+  const mcpPath = path.join(absolutePath, ".mcp.json");
+  if (existsSync(mcpPath)) {
+    try {
+      const mcpContent = readFileSync(mcpPath, "utf-8");
+      JSON.parse(mcpContent);
+    } catch {
+      warnings.push(".mcp.json exists but contains invalid JSON");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    manifest,
+    format,
+    errors,
+    warnings
+  };
+}
+function checkDirectoryHasFiles(dirPath, extension) {
+  if (!existsSync(dirPath)) {
+    return false;
+  }
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    return entries.some((entry) => entry.isFile() && entry.name.endsWith(extension));
+  } catch {
+    return false;
+  }
+}
+function checkDirectoryHasSkills(skillsDir) {
+  if (!existsSync(skillsDir)) {
+    return false;
+  }
+  try {
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    return entries.some((entry) => {
+      if (!entry.isDirectory()) return false;
+      const skillMdPath = path.join(skillsDir, entry.name, "SKILL.md");
+      return existsSync(skillMdPath);
+    });
+  } catch {
+    return false;
+  }
+}
+function tryLoadManifest(pluginPath, returnFormat) {
+  const dextoManifestPath = path.join(pluginPath, ".dexto-plugin", "plugin.json");
+  const claudeManifestPath = path.join(pluginPath, ".claude-plugin", "plugin.json");
+  let manifestPath;
+  let format;
+  if (existsSync(dextoManifestPath)) {
+    manifestPath = dextoManifestPath;
+    format = "dexto";
+  } else if (existsSync(claudeManifestPath)) {
+    manifestPath = claudeManifestPath;
+    format = "claude-code";
+  } else {
+    return null;
+  }
+  try {
+    const content = readFileSync(manifestPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const schema = format === "dexto" ? DextoPluginManifestSchema : PluginManifestSchema;
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      return null;
+    }
+    if (returnFormat) {
+      return { manifest: result.data, format };
+    }
+    return result.data;
+  } catch {
+    return null;
+  }
+}
+export {
+  tryLoadManifest,
+  validatePluginDirectory
+};

package/dist/preferences/errors.cjs

@@ -66,6 +66,17 @@ class PreferenceError {
     }));
     return new import_core.DextoValidationError(issues);
   }
+  static invalidAgentId(agentId) {
+    return new import_core.DextoValidationError([
+      {
+        code: import_error_codes.PreferenceErrorCode.INVALID_PREFERENCE_VALUE,
+        message: `agentId is invalid: ${agentId}`,
+        scope: "preference",
+        type: import_core.ErrorType.USER,
+        severity: "error"
+      }
+    ]);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/preferences/errors.d.ts

@@ -14,5 +14,6 @@ export declare class PreferenceError {
         cause: string;
     }>;
     static validationFailed(zodError: ZodError): DextoValidationError;
+    static invalidAgentId(agentId: string): DextoValidationError;
 }
 //# sourceMappingURL=errors.d.ts.map

package/dist/preferences/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/preferences/errors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAa,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAC;AAGpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvD,qBAAa,eAAe;IACxB,MAAM,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM;;;IAW3C,MAAM,CAAC,aAAa,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAW3D,MAAM,CAAC,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAW5D,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ;CAW7C"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/preferences/errors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAa,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAC;AAGpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvD,qBAAa,eAAe;IACxB,MAAM,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM;;;IAW3C,MAAM,CAAC,aAAa,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAW3D,MAAM,CAAC,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAW5D,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ;IAY1C,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM;CAWxC"}