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

package/dist/module.mjs

@@ -6,7 +6,7 @@ import { SOCKET_PATH, destroyClaudeSession } from '../dist/runtime/server/claude
 
 const DEVTOOLS_UI_ROUTE = "/__claude-devtools";
 const DEVTOOLS_UI_LOCAL_PORT = 3300;
-function setupDevToolsUI(nuxt, resolver) {
+function setupDevToolsUI(nuxt, resolver, options = {}) {
   const clientPath = resolver.resolve("./client");
   const isProductionBuild = existsSync(clientPath);
   if (isProductionBuild) {
@@ -30,13 +30,14 @@ function setupDevToolsUI(nuxt, resolver) {
     });
   }
   nuxt.hook("devtools:customTabs", (tabs) => {
+    const hash = options.debug ? "#debug=true" : "";
     tabs.push({
       name: "claude-ai",
       title: "AI",
       icon: "carbon:machine-learning-model",
       view: {
         type: "iframe",
-        src: DEVTOOLS_UI_ROUTE
+        src: `${DEVTOOLS_UI_ROUTE}${hash}`
       }
     });
   });
@@ -50,6 +51,7 @@ const module$1 = defineNuxtModule({
   },
   defaults: {
     enabled: true,
+    debug: false,
     claude: {
       command: "claude",
       args: []
@@ -59,6 +61,9 @@ const module$1 = defineNuxtModule({
     if (!nuxt.options.dev || !options.enabled) {
       return;
     }
+    if (options.debug) {
+      process.env.CLAUDE_DEVTOOLS_DEBUG = "true";
+    }
     const resolver = createResolver(import.meta.url);
     const tunnel = getTunnelConfig();
     if (tunnel) {
@@ -75,7 +80,8 @@ const module$1 = defineNuxtModule({
     };
     nuxt.options.runtimeConfig.public.claudeDevtools = {
       socketPath: SOCKET_PATH,
-      tunnelOrigin: tunnel?.origin || null
+      tunnelOrigin: tunnel?.origin || null,
+      debug: options?.debug || false
     };
     addServerPlugin(resolver.resolve("./runtime/server/plugins/socket.io"));
     log("Added Socket.IO Nitro plugin");
@@ -83,7 +89,7 @@ const module$1 = defineNuxtModule({
       log("Cleaning up Claude session");
       destroyClaudeSession();
     });
-    setupDevToolsUI(nuxt, resolver);
+    setupDevToolsUI(nuxt, resolver, { debug: options.debug });
   }
 });
 

package/dist/runtime/logger.js

@@ -1,7 +1,25 @@
 const PREFIX = "[nuxt-claude-devtools]";
+let _debugEnabled = null;
+function isDebugEnabled() {
+  if (_debugEnabled !== null) {
+    return _debugEnabled;
+  }
+  try {
+    const { useRuntimeConfig } = require("nitropack/runtime");
+    const config = useRuntimeConfig();
+    _debugEnabled = config.public?.claudeDevtools?.debug === true;
+    return _debugEnabled;
+  } catch {
+    _debugEnabled = process.env.CLAUDE_DEVTOOLS_DEBUG === "true";
+    return _debugEnabled;
+  }
+}
 export function createLogger(subsystem, options = {}) {
   const tag = `${PREFIX} [${subsystem}]`;
   return function log(message, data) {
+    if (!isDebugEnabled()) {
+      return;
+    }
     const ts = options.timestamp ? ` [${(/* @__PURE__ */ new Date()).toISOString()}]` : "";
     if (data !== void 0) {
       console.log(`${tag}${ts} ${message}`, data);

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

@@ -0,0 +1,31 @@
+export interface Agent {
+    name: string;
+    description: string;
+    prompt: string;
+    rawContent: string;
+    tools?: string[];
+    disallowedTools?: string[];
+    model?: string;
+    permissionMode?: 'default' | 'acceptEdits' | 'dontAsk' | 'bypassPermissions' | 'plan';
+    skills?: string[];
+    updatedAt: string;
+}
+export declare class AgentsManager {
+    private agentsDir;
+    constructor(projectPath: string);
+    private parseFrontmatter;
+    private buildFrontmatter;
+    getAgents(): Agent[];
+    getAgent(name: string): Agent | null;
+    saveAgent(agent: {
+        name: string;
+        description: string;
+        prompt: string;
+        tools?: string[];
+        disallowedTools?: string[];
+        model?: string;
+        permissionMode?: Agent['permissionMode'];
+        skills?: string[];
+    }): Agent;
+    deleteAgent(name: string): boolean;
+}

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

@@ -0,0 +1,193 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { createLogger } from "../logger.js";
+const log = createLogger("agents", { timestamp: true });
+export class AgentsManager {
+  agentsDir;
+  constructor(projectPath) {
+    this.agentsDir = join(projectPath, ".claude", "agents");
+    if (!existsSync(this.agentsDir)) {
+      mkdirSync(this.agentsDir, { recursive: true });
+      log("Created agents directory", { path: this.agentsDir });
+    }
+  }
+  // Parse YAML frontmatter from markdown content
+  parseFrontmatter(content) {
+    const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      return { frontmatter: {}, body: content.trim() };
+    }
+    const [, yaml, body] = match;
+    const frontmatter = {};
+    let inSkillsArray = false;
+    const skillsList = [];
+    for (const line of yaml.split("\n")) {
+      if (inSkillsArray) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("- ")) {
+          skillsList.push(trimmed.slice(2).trim());
+          continue;
+        } else if (trimmed && !trimmed.startsWith("-")) {
+          inSkillsArray = false;
+        } else {
+          continue;
+        }
+      }
+      const colonIndex = line.indexOf(":");
+      if (colonIndex === -1) continue;
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      switch (key) {
+        case "name":
+          frontmatter.name = value;
+          break;
+        case "description":
+          frontmatter.description = value;
+          break;
+        case "tools":
+          frontmatter.tools = value;
+          break;
+        case "disallowedTools":
+          frontmatter.disallowedTools = value;
+          break;
+        case "model":
+          frontmatter.model = value;
+          break;
+        case "permissionMode":
+          frontmatter.permissionMode = value;
+          break;
+        case "skills":
+          if (value) {
+            frontmatter.skills = value.split(",").map((s) => s.trim()).filter((s) => s);
+          } else {
+            inSkillsArray = true;
+          }
+          break;
+      }
+    }
+    if (skillsList.length > 0) {
+      frontmatter.skills = skillsList;
+    }
+    return { frontmatter, body: body.trim() };
+  }
+  // Build frontmatter string
+  buildFrontmatter(agent) {
+    const lines = ["---"];
+    if (agent.name) {
+      lines.push(`name: ${agent.name}`);
+    }
+    if (agent.description) {
+      lines.push(`description: ${agent.description}`);
+    }
+    if (agent.tools && agent.tools.length > 0) {
+      lines.push(`tools: ${agent.tools.join(", ")}`);
+    }
+    if (agent.disallowedTools && agent.disallowedTools.length > 0) {
+      lines.push(`disallowedTools: ${agent.disallowedTools.join(", ")}`);
+    }
+    if (agent.model) {
+      lines.push(`model: ${agent.model}`);
+    }
+    if (agent.permissionMode) {
+      lines.push(`permissionMode: ${agent.permissionMode}`);
+    }
+    if (agent.skills && agent.skills.length > 0) {
+      lines.push("skills:");
+      for (const skill of agent.skills) {
+        lines.push(`  - ${skill}`);
+      }
+    }
+    lines.push("---");
+    return lines.join("\n");
+  }
+  // Get all agents
+  getAgents() {
+    const agents = [];
+    if (!existsSync(this.agentsDir)) return agents;
+    const entries = readdirSync(this.agentsDir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const fullPath = join(this.agentsDir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) continue;
+      const rawContent = readFileSync(fullPath, "utf-8");
+      const { frontmatter, body } = this.parseFrontmatter(rawContent);
+      agents.push({
+        name: frontmatter.name || basename(entry, ".md"),
+        description: frontmatter.description || "",
+        prompt: body,
+        rawContent,
+        tools: frontmatter.tools ? frontmatter.tools.split(",").map((s) => s.trim()) : void 0,
+        disallowedTools: frontmatter.disallowedTools ? frontmatter.disallowedTools.split(",").map((s) => s.trim()) : void 0,
+        model: frontmatter.model,
+        permissionMode: frontmatter.permissionMode,
+        skills: frontmatter.skills,
+        updatedAt: stat.mtime.toISOString()
+      });
+    }
+    return agents.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  // Get single agent
+  getAgent(name) {
+    const fileName = name.endsWith(".md") ? name : `${name}.md`;
+    const fullPath = join(this.agentsDir, fileName);
+    if (!existsSync(fullPath)) return null;
+    const stat = statSync(fullPath);
+    const rawContent = readFileSync(fullPath, "utf-8");
+    const { frontmatter, body } = this.parseFrontmatter(rawContent);
+    return {
+      name: frontmatter.name || basename(fileName, ".md"),
+      description: frontmatter.description || "",
+      prompt: body,
+      rawContent,
+      tools: frontmatter.tools ? frontmatter.tools.split(",").map((s) => s.trim()) : void 0,
+      disallowedTools: frontmatter.disallowedTools ? frontmatter.disallowedTools.split(",").map((s) => s.trim()) : void 0,
+      model: frontmatter.model,
+      permissionMode: frontmatter.permissionMode,
+      skills: frontmatter.skills,
+      updatedAt: stat.mtime.toISOString()
+    };
+  }
+  // Create or update agent
+  saveAgent(agent) {
+    const safeName = agent.name.replace(/[^\w-]/g, "-").toLowerCase();
+    const fileName = `${safeName}.md`;
+    const fullPath = join(this.agentsDir, fileName);
+    const frontmatter = this.buildFrontmatter({
+      name: safeName,
+      description: agent.description,
+      tools: agent.tools,
+      disallowedTools: agent.disallowedTools,
+      model: agent.model,
+      permissionMode: agent.permissionMode,
+      skills: agent.skills
+    });
+    const rawContent = `${frontmatter}
+
+${agent.prompt}`;
+    writeFileSync(fullPath, rawContent, "utf-8");
+    log("Saved agent", { name: safeName, path: fullPath });
+    return {
+      name: safeName,
+      description: agent.description,
+      prompt: agent.prompt,
+      rawContent,
+      tools: agent.tools,
+      disallowedTools: agent.disallowedTools,
+      model: agent.model,
+      permissionMode: agent.permissionMode,
+      skills: agent.skills,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // Delete agent
+  deleteAgent(name) {
+    const fileName = name.endsWith(".md") ? name : `${name}.md`;
+    const fullPath = join(this.agentsDir, fileName);
+    if (!existsSync(fullPath)) return false;
+    unlinkSync(fullPath);
+    log("Deleted agent", { name });
+    return true;
+  }
+}

package/dist/runtime/server/claude-session.d.ts

@@ -11,9 +11,24 @@ export declare class ClaudeSession {
     private io;
     private isProcessing;
     private continueSession;
+    private historyManager;
+    private docsManager;
+    private commandsManager;
+    private agentsManager;
+    private skillsManager;
+    private claudeSessionId;
+    private parseBuffer;
+    private currentContentBlocks;
+    private currentMessageId;
+    private currentModel;
+    private accumulatedText;
     constructor(config: ClaudeSessionConfig);
     attachSocketIO(io: SocketServer): void;
     destroy(): void;
+    private resetStreamState;
+    private buildSystemPrompt;
+    private parseStreamChunk;
+    private processStreamEvent;
     private sendMessage;
     private getMcpServers;
     private addMcpServer;