@oro.ad/nuxt-claude-devtools 1.2.0 → 1.3.0

package/dist/runtime/server/plugins-manager.js

@@ -0,0 +1,338 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+import {
+  AGENTS_SUBDIR,
+  CLAUDE_DIR,
+  CLAUDE_SETTINGS_FILE,
+  CLAUDE_SETTINGS_LOCAL_FILE,
+  COMMANDS_SUBDIR,
+  DEFAULT_PLUGINS_CACHE_PATH,
+  PLUGIN_MANIFEST_DIR,
+  PLUGIN_MANIFEST_FILE,
+  SKILL_FILE,
+  SKILLS_SUBDIR
+} from "./constants.js";
+const log = createLogger("plugins", { timestamp: true });
+export class PluginsManager {
+  projectPath;
+  pluginsCachePath;
+  userClaudeDir;
+  constructor(projectPath, customCachePath) {
+    this.projectPath = projectPath;
+    this.userClaudeDir = join(homedir(), CLAUDE_DIR);
+    if (customCachePath) {
+      this.pluginsCachePath = customCachePath;
+    } else {
+      this.pluginsCachePath = join(homedir(), DEFAULT_PLUGINS_CACHE_PATH);
+    }
+    log("PluginsManager initialized", {
+      projectPath,
+      pluginsCachePath: this.pluginsCachePath,
+      userClaudeDir: this.userClaudeDir
+    });
+  }
+  // ============ Settings Reading ============
+  readSettingsFile(path) {
+    try {
+      if (!existsSync(path)) {
+        return null;
+      }
+      const content = readFileSync(path, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      log("Failed to read settings file", { path, error });
+      return null;
+    }
+  }
+  getUserSettings() {
+    const path = join(this.userClaudeDir, CLAUDE_SETTINGS_FILE);
+    return this.readSettingsFile(path);
+  }
+  getProjectSettings() {
+    const path = join(this.projectPath, CLAUDE_DIR, CLAUDE_SETTINGS_FILE);
+    return this.readSettingsFile(path);
+  }
+  getLocalSettings() {
+    const path = join(this.projectPath, CLAUDE_DIR, CLAUDE_SETTINGS_LOCAL_FILE);
+    return this.readSettingsFile(path);
+  }
+  // ============ Plugin Discovery ============
+  parsePluginId(pluginId) {
+    const atIndex = pluginId.lastIndexOf("@");
+    if (atIndex === -1 || atIndex === 0) {
+      return null;
+    }
+    return {
+      name: pluginId.slice(0, atIndex),
+      marketplace: pluginId.slice(atIndex + 1)
+    };
+  }
+  findPluginInCache(pluginName, marketplace) {
+    const possibleBasePaths = [
+      join(this.pluginsCachePath, marketplace, pluginName),
+      join(this.pluginsCachePath, `${pluginName}@${marketplace}`),
+      join(this.pluginsCachePath, pluginName)
+    ];
+    for (const basePath of possibleBasePaths) {
+      if (!existsSync(basePath) || !statSync(basePath).isDirectory()) {
+        continue;
+      }
+      const directManifest = join(basePath, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+      if (existsSync(directManifest)) {
+        return basePath;
+      }
+      try {
+        const entries = readdirSync(basePath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith(".")) {
+            const versionPath = join(basePath, entry.name);
+            const versionManifest = join(versionPath, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+            if (existsSync(versionManifest)) {
+              return versionPath;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  readPluginManifest(pluginPath) {
+    const manifestPath = join(pluginPath, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+    try {
+      if (!existsSync(manifestPath)) {
+        return null;
+      }
+      const content = readFileSync(manifestPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      log("Failed to read plugin manifest", { manifestPath, error });
+      return null;
+    }
+  }
+  // ============ Public API: Plugins ============
+  normalizePluginList(list, filterEnabled) {
+    if (!list) return [];
+    if (Array.isArray(list)) return list;
+    return Object.entries(list).filter(([_, enabled]) => filterEnabled === void 0 || enabled === filterEnabled).map(([id]) => id);
+  }
+  getInstalledPlugins() {
+    const plugins = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    const addPlugins = (enabledList, disabledList, scope) => {
+      for (const pluginId of this.normalizePluginList(enabledList, true)) {
+        if (seenIds.has(pluginId)) continue;
+        seenIds.add(pluginId);
+        const parsed = this.parsePluginId(pluginId);
+        if (!parsed) {
+          log("Invalid plugin ID format", { pluginId });
+          continue;
+        }
+        const cachePath = this.findPluginInCache(parsed.name, parsed.marketplace);
+        const manifest = cachePath ? this.readPluginManifest(cachePath) : void 0;
+        plugins.push({
+          id: pluginId,
+          name: parsed.name,
+          marketplace: parsed.marketplace,
+          scope,
+          enabled: true,
+          manifest: manifest || void 0,
+          cachePath: cachePath || void 0
+        });
+      }
+      for (const pluginId of this.normalizePluginList(disabledList)) {
+        if (seenIds.has(pluginId)) continue;
+        seenIds.add(pluginId);
+        const parsed = this.parsePluginId(pluginId);
+        if (!parsed) continue;
+        const cachePath = this.findPluginInCache(parsed.name, parsed.marketplace);
+        const manifest = cachePath ? this.readPluginManifest(cachePath) : void 0;
+        plugins.push({
+          id: pluginId,
+          name: parsed.name,
+          marketplace: parsed.marketplace,
+          scope,
+          enabled: false,
+          manifest: manifest || void 0,
+          cachePath: cachePath || void 0
+        });
+      }
+    };
+    const userSettings = this.getUserSettings();
+    const projectSettings = this.getProjectSettings();
+    const localSettings = this.getLocalSettings();
+    addPlugins(userSettings?.enabledPlugins, userSettings?.disabledPlugins, "user");
+    addPlugins(projectSettings?.enabledPlugins, projectSettings?.disabledPlugins, "project");
+    addPlugins(localSettings?.enabledPlugins, localSettings?.disabledPlugins, "local");
+    return plugins;
+  }
+  // ============ Public API: Marketplaces ============
+  getMarketplaces() {
+    const marketplaces = [];
+    const seenNames = /* @__PURE__ */ new Set();
+    marketplaces.push({
+      name: "claude-plugins-official",
+      source: "anthropic/claude-plugins",
+      autoUpdate: true
+    });
+    seenNames.add("claude-plugins-official");
+    const addMarketplaces = (settings) => {
+      for (const mp of settings?.extraKnownMarketplaces || []) {
+        if (seenNames.has(mp.name)) continue;
+        seenNames.add(mp.name);
+        marketplaces.push({
+          name: mp.name,
+          source: mp.source,
+          autoUpdate: mp.autoUpdate
+        });
+      }
+    };
+    addMarketplaces(this.getUserSettings());
+    addMarketplaces(this.getProjectSettings());
+    addMarketplaces(this.getLocalSettings());
+    return marketplaces;
+  }
+  // ============ Public API: Plugin Resources ============
+  parseFrontmatter(content) {
+    const frontmatter = {};
+    let body = content;
+    if (content.startsWith("---")) {
+      const endIndex = content.indexOf("---", 3);
+      if (endIndex !== -1) {
+        const yamlContent = content.slice(3, endIndex).trim();
+        body = content.slice(endIndex + 3).trim();
+        for (const line of yamlContent.split("\n")) {
+          const colonIndex = line.indexOf(":");
+          if (colonIndex !== -1) {
+            const key = line.slice(0, colonIndex).trim();
+            const value = line.slice(colonIndex + 1).trim();
+            frontmatter[key] = value;
+          }
+        }
+      }
+    }
+    return { frontmatter, body };
+  }
+  getPluginSkills(pluginPath, pluginName) {
+    const skills = [];
+    const skillsDir = join(pluginPath, SKILLS_SUBDIR);
+    if (!existsSync(skillsDir)) {
+      return skills;
+    }
+    try {
+      const entries = readdirSync(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillFile = join(skillsDir, entry.name, SKILL_FILE);
+        if (!existsSync(skillFile)) continue;
+        try {
+          const content = readFileSync(skillFile, "utf-8");
+          const { frontmatter, body } = this.parseFrontmatter(content);
+          skills.push({
+            name: frontmatter.name || entry.name,
+            description: frontmatter.description || "",
+            content: body,
+            pluginName,
+            fullName: `${pluginName}:${frontmatter.name || entry.name}`
+          });
+        } catch (error) {
+          log("Failed to read plugin skill", { skillFile, error });
+        }
+      }
+    } catch (error) {
+      log("Failed to read plugin skills directory", { skillsDir, error });
+    }
+    return skills;
+  }
+  getPluginCommands(pluginPath, pluginName) {
+    const commands = [];
+    const commandsDir = join(pluginPath, COMMANDS_SUBDIR);
+    if (!existsSync(commandsDir)) {
+      return commands;
+    }
+    try {
+      const entries = readdirSync(commandsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+        const commandFile = join(commandsDir, entry.name);
+        const commandName = entry.name.replace(/\.md$/, "");
+        try {
+          const content = readFileSync(commandFile, "utf-8");
+          const { frontmatter, body } = this.parseFrontmatter(content);
+          commands.push({
+            name: commandName,
+            description: frontmatter.description,
+            content: body,
+            pluginName,
+            fullName: `${pluginName}:${commandName}`
+          });
+        } catch (error) {
+          log("Failed to read plugin command", { commandFile, error });
+        }
+      }
+    } catch (error) {
+      log("Failed to read plugin commands directory", { commandsDir, error });
+    }
+    return commands;
+  }
+  getPluginAgents(pluginPath, pluginName) {
+    const agents = [];
+    const agentsDir = join(pluginPath, AGENTS_SUBDIR);
+    if (!existsSync(agentsDir)) {
+      return agents;
+    }
+    try {
+      const entries = readdirSync(agentsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+        const agentFile = join(agentsDir, entry.name);
+        const agentName = entry.name.replace(/\.md$/, "");
+        try {
+          const content = readFileSync(agentFile, "utf-8");
+          const { frontmatter, body } = this.parseFrontmatter(content);
+          agents.push({
+            name: frontmatter.name || agentName,
+            description: frontmatter.description || "",
+            prompt: body,
+            pluginName
+          });
+        } catch (error) {
+          log("Failed to read plugin agent", { agentFile, error });
+        }
+      }
+    } catch (error) {
+      log("Failed to read plugin agents directory", { agentsDir, error });
+    }
+    return agents;
+  }
+  // ============ Aggregate Methods ============
+  getAllPluginSkills() {
+    const skills = [];
+    const plugins = this.getInstalledPlugins();
+    for (const plugin of plugins) {
+      if (!plugin.enabled || !plugin.cachePath) continue;
+      skills.push(...this.getPluginSkills(plugin.cachePath, plugin.name));
+    }
+    return skills;
+  }
+  getAllPluginCommands() {
+    const commands = [];
+    const plugins = this.getInstalledPlugins();
+    for (const plugin of plugins) {
+      if (!plugin.enabled || !plugin.cachePath) continue;
+      commands.push(...this.getPluginCommands(plugin.cachePath, plugin.name));
+    }
+    return commands;
+  }
+  getAllPluginAgents() {
+    const agents = [];
+    const plugins = this.getInstalledPlugins();
+    for (const plugin of plugins) {
+      if (!plugin.enabled || !plugin.cachePath) continue;
+      agents.push(...this.getPluginAgents(plugin.cachePath, plugin.name));
+    }
+    return agents;
+  }
+}

package/dist/runtime/server/settings-manager.d.ts

@@ -0,0 +1,17 @@
+export interface DevToolsSettings {
+    criticalFiles: {
+        autoConfirm: boolean;
+    };
+}
+export declare class SettingsManager {
+    private settingsPath;
+    private settings;
+    constructor(rootDir: string);
+    private loadSettings;
+    private mergeWithDefaults;
+    private saveSettings;
+    getSettings(): DevToolsSettings;
+    updateSettings(updates: Partial<DevToolsSettings>): DevToolsSettings;
+    isAutoConfirmEnabled(): boolean;
+    setAutoConfirm(value: boolean): void;
+}

package/dist/runtime/server/settings-manager.js

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createLogger } from "../logger.js";
+import { DEVTOOLS_DATA_DIR, SETTINGS_FILE } from "./constants.js";
+const log = createLogger("settings", { timestamp: true });
+const DEFAULT_SETTINGS = {
+  criticalFiles: {
+    autoConfirm: false
+    // By default, require user confirmation
+  }
+};
+export class SettingsManager {
+  settingsPath;
+  settings;
+  constructor(rootDir) {
+    this.settingsPath = join(rootDir, DEVTOOLS_DATA_DIR, SETTINGS_FILE);
+    this.settings = this.loadSettings();
+  }
+  loadSettings() {
+    try {
+      if (existsSync(this.settingsPath)) {
+        const data = readFileSync(this.settingsPath, "utf-8");
+        const parsed = JSON.parse(data);
+        return this.mergeWithDefaults(parsed);
+      }
+    } catch (error) {
+      log("Failed to load settings, using defaults", { error });
+    }
+    return { ...DEFAULT_SETTINGS };
+  }
+  mergeWithDefaults(partial) {
+    return {
+      criticalFiles: {
+        ...DEFAULT_SETTINGS.criticalFiles,
+        ...partial.criticalFiles
+      }
+    };
+  }
+  saveSettings() {
+    try {
+      const dir = dirname(this.settingsPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2));
+      log("Settings saved");
+    } catch (error) {
+      log("Failed to save settings", { error });
+    }
+  }
+  getSettings() {
+    return { ...this.settings };
+  }
+  updateSettings(updates) {
+    this.settings = this.mergeWithDefaults({
+      ...this.settings,
+      ...updates
+    });
+    this.saveSettings();
+    return this.getSettings();
+  }
+  // Convenience methods
+  isAutoConfirmEnabled() {
+    return this.settings.criticalFiles.autoConfirm;
+  }
+  setAutoConfirm(value) {
+    this.settings.criticalFiles.autoConfirm = value;
+    this.saveSettings();
+  }
+}

package/dist/runtime/server/share-manager.d.ts

@@ -0,0 +1,24 @@
+export interface ShareUser {
+    id: string;
+    nickname: string;
+    joinedAt: string;
+    lastSeen: string;
+}
+export interface ShareStore {
+    version: 1;
+    users: ShareUser[];
+}
+export declare class ShareManager {
+    private storePath;
+    constructor(projectPath: string);
+    private loadStore;
+    private saveStore;
+    getUsers(): ShareUser[];
+    getUser(id: string): ShareUser | null;
+    getUserByNickname(nickname: string): ShareUser | null;
+    registerUser(id: string, nickname: string): ShareUser;
+    updateLastSeen(id: string): void;
+    isNicknameAvailable(nickname: string, excludeId?: string): boolean;
+    isActive(): boolean;
+    static generateUserId(): string;
+}

package/dist/runtime/server/share-manager.js

@@ -0,0 +1,96 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createLogger } from "../logger.js";
+import { DEVTOOLS_DATA_DIR, SHARE_FILE } from "./constants.js";
+const log = createLogger("share", { timestamp: true });
+export class ShareManager {
+  storePath;
+  constructor(projectPath) {
+    this.storePath = join(projectPath, DEVTOOLS_DATA_DIR, SHARE_FILE);
+  }
+  loadStore() {
+    try {
+      if (existsSync(this.storePath)) {
+        const data = readFileSync(this.storePath, "utf-8");
+        return JSON.parse(data);
+      }
+    } catch (error) {
+      log("Failed to load share store", { error });
+    }
+    return {
+      version: 1,
+      users: []
+    };
+  }
+  saveStore(store) {
+    const dir = dirname(this.storePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(this.storePath, JSON.stringify(store, null, 2));
+    log("Saved share store");
+  }
+  // Get all users
+  getUsers() {
+    return this.loadStore().users;
+  }
+  // Get user by ID
+  getUser(id) {
+    const store = this.loadStore();
+    return store.users.find((u) => u.id === id) || null;
+  }
+  // Get user by nickname
+  getUserByNickname(nickname) {
+    const store = this.loadStore();
+    return store.users.find((u) => u.nickname.toLowerCase() === nickname.toLowerCase()) || null;
+  }
+  // Register or update user
+  registerUser(id, nickname) {
+    const store = this.loadStore();
+    const existingIndex = store.users.findIndex((u) => u.id === id);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (existingIndex >= 0) {
+      store.users[existingIndex].nickname = nickname;
+      store.users[existingIndex].lastSeen = now;
+      this.saveStore(store);
+      log("Updated user", { id, nickname });
+      return store.users[existingIndex];
+    }
+    const user = {
+      id,
+      nickname,
+      joinedAt: now,
+      lastSeen: now
+    };
+    store.users.push(user);
+    this.saveStore(store);
+    log("Registered new user", { id, nickname });
+    return user;
+  }
+  // Update last seen
+  updateLastSeen(id) {
+    const store = this.loadStore();
+    const user = store.users.find((u) => u.id === id);
+    if (user) {
+      user.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.saveStore(store);
+    }
+  }
+  // Check if nickname is available
+  isNicknameAvailable(nickname, excludeId) {
+    const store = this.loadStore();
+    const existing = store.users.find(
+      (u) => u.nickname.toLowerCase() === nickname.toLowerCase() && u.id !== excludeId
+    );
+    return !existing;
+  }
+  // Check if sharing is active (has registered users)
+  isActive() {
+    const store = this.loadStore();
+    return store.users.length > 0;
+  }
+  // Generate user ID
+  static generateUserId() {
+    return Math.random().toString(36).substring(2, 10);
+  }
+}

package/dist/runtime/server/skills-manager.d.ts

@@ -1,3 +1,4 @@
+import { MarkdownResourceManager } from './base-resource-manager.js';
 export interface Skill {
     name: string;
     description: string;
@@ -11,12 +12,24 @@ export interface Skill {
     context?: 'fork';
     agent?: string;
     updatedAt: string;
+    /** Source of the skill: 'project' for local .claude/, or plugin name */
+    source?: string;
 }
-export declare class SkillsManager {
-    private skillsDir;
+interface SkillFrontmatter {
+    'name'?: string;
+    'description'?: string;
+    'argument-hint'?: string;
+    'disable-model-invocation'?: boolean;
+    'user-invocable'?: boolean;
+    'allowed-tools'?: string;
+    'model'?: string;
+    'context'?: string;
+    'agent'?: string;
+}
+export declare class SkillsManager extends MarkdownResourceManager<Skill, SkillFrontmatter> {
     constructor(projectPath: string);
-    private parseFrontmatter;
-    private buildFrontmatter;
+    protected buildFrontmatter(skill: Partial<Skill>): string;
+    protected toResource(name: string, frontmatter: SkillFrontmatter, body: string, rawContent: string, updatedAt: string): Skill;
     getSkills(): Skill[];
     getSkill(name: string): Skill | null;
     getSkillNames(): string[];
@@ -34,3 +47,4 @@ export declare class SkillsManager {
     }): Skill;
     deleteSkill(name: string): boolean;
 }
+export {};