aem-ext-daemon 0.4.2 → 0.5.0

package/dist/capabilities/fs.d.ts

@@ -17,5 +17,10 @@ export declare function readFile(filePath: string): string;
 export declare function mkdir(dirPath: string): string;
 /** Write content to a file. Creates parent directories if needed. */
 export declare function writeFile(filePath: string, content: string): string;
+/**
+ * Find all files recursively and return as flat JSON array of relative paths.
+ * Used for file search and @ mention autocomplete.
+ */
+export declare function findFiles(dirPath: string, maxDepth?: number): string;
 /** Recursive directory listing up to a max depth. */
 export declare function listRecursive(dirPath: string, maxDepth?: number): string;

package/dist/capabilities/fs.js

@@ -65,6 +65,43 @@ export function writeFile(filePath, content) {
     fs.writeFileSync(filePath, content, "utf-8");
     return `Written ${content.length} bytes to ${filePath}`;
 }
+/**
+ * Find all files recursively and return as flat JSON array of relative paths.
+ * Used for file search and @ mention autocomplete.
+ */
+export function findFiles(dirPath, maxDepth = 8) {
+    const SKIP = new Set([
+        "node_modules", "__pycache__", "dist", "build", ".git",
+        ".next", ".cache", "coverage", ".turbo", ".parcel-cache",
+    ]);
+    const MAX_FILES = 5000;
+    const files = [];
+    function walk(dir, rel, depth) {
+        if (depth > maxDepth || files.length >= MAX_FILES)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const filtered = entries.filter((e) => !e.name.startsWith(".") && !SKIP.has(e.name));
+        for (const entry of filtered) {
+            const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                walk(path.join(dir, entry.name), relPath, depth + 1);
+            }
+            else {
+                files.push(relPath);
+                if (files.length >= MAX_FILES)
+                    return;
+            }
+        }
+    }
+    walk(dirPath, "", 0);
+    return JSON.stringify(files);
+}
 /** Recursive directory listing up to a max depth. */
 export function listRecursive(dirPath, maxDepth = 3) {
     const result = [];

package/dist/capabilities/mcp.d.ts

@@ -0,0 +1,38 @@
+/**
+ * MCP capabilities — manage stdio-based MCP server processes on the local machine.
+ *
+ * Each server is a child process communicating via stdin/stdout using the MCP protocol.
+ * The daemon manages the lifecycle and proxies tool calls from the cloud server.
+ */
+/**
+ * Start a stdio MCP server process and discover its tools.
+ *
+ * @param config Server configuration
+ * @returns JSON string with status and tool list
+ */
+export declare function startServer(config: {
+    id: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}): Promise<string>;
+/**
+ * Stop a running MCP server and kill its process.
+ */
+export declare function stopServer(id: string): Promise<string>;
+/**
+ * Call a tool on a running MCP server.
+ */
+export declare function callTool(serverId: string, toolName: string, args: Record<string, unknown>): Promise<string>;
+/**
+ * List tools for a running MCP server.
+ */
+export declare function listTools(serverId: string): string;
+/**
+ * Get status of all running MCP servers.
+ */
+export declare function getStatus(): string;
+/**
+ * Stop all running MCP servers. Called during daemon shutdown.
+ */
+export declare function stopAll(): Promise<void>;

package/dist/capabilities/mcp.js

@@ -0,0 +1,162 @@
+/**
+ * MCP capabilities — manage stdio-based MCP server processes on the local machine.
+ *
+ * Each server is a child process communicating via stdin/stdout using the MCP protocol.
+ * The daemon manages the lifecycle and proxies tool calls from the cloud server.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { logInfo, logError } from "../logger.js";
+// Active MCP server processes, keyed by server ID
+const servers = new Map();
+/**
+ * Start a stdio MCP server process and discover its tools.
+ *
+ * @param config Server configuration
+ * @returns JSON string with status and tool list
+ */
+export async function startServer(config) {
+    const { id, command, args, env } = config;
+    // Stop existing instance if running
+    if (servers.has(id)) {
+        await stopServer(id);
+    }
+    logInfo(`MCP: starting server "${id}" — ${command} ${(args || []).join(" ")}`);
+    const transport = new StdioClientTransport({
+        command,
+        args: args || [],
+        env: env ? { ...process.env, ...env } : undefined,
+    });
+    const client = new Client({
+        name: "aem-ext-daemon",
+        version: "1.0.0",
+    });
+    try {
+        await client.connect(transport);
+        // Discover tools
+        const result = await client.listTools();
+        const tools = (result.tools || []).map((t) => ({
+            name: t.name,
+            description: t.description || "",
+            inputSchema: t.inputSchema || { type: "object", properties: {} },
+        }));
+        // Try to get the PID from the transport's subprocess
+        let pid;
+        try {
+            // The StdioClientTransport exposes the child process internally
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const tp = transport;
+            pid = tp._process?.pid || tp.process?.pid;
+        }
+        catch {
+            // PID not available — not critical
+        }
+        const managed = { id, client, transport, tools, pid };
+        servers.set(id, managed);
+        logInfo(`MCP: server "${id}" started — ${tools.length} tools discovered${pid ? ` (PID ${pid})` : ""}`);
+        return JSON.stringify({
+            running: true,
+            serverId: id,
+            pid,
+            toolCount: tools.length,
+            tools: tools.map((t) => ({ name: t.name, description: t.description })),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logError("mcp:start", message, 0);
+        // Ensure cleanup on failure
+        try {
+            await client.close();
+        }
+        catch { /* ignore */ }
+        return JSON.stringify({
+            running: false,
+            serverId: id,
+            error: message,
+        });
+    }
+}
+/**
+ * Stop a running MCP server and kill its process.
+ */
+export async function stopServer(id) {
+    const server = servers.get(id);
+    if (!server) {
+        return JSON.stringify({ stopped: true, serverId: id, wasRunning: false });
+    }
+    logInfo(`MCP: stopping server "${id}"`);
+    try {
+        await server.client.close();
+    }
+    catch {
+        // Force-kill if close doesn't work
+        if (server.pid) {
+            try {
+                process.kill(server.pid, "SIGTERM");
+            }
+            catch { /* already dead */ }
+        }
+    }
+    servers.delete(id);
+    return JSON.stringify({ stopped: true, serverId: id, wasRunning: true });
+}
+/**
+ * Call a tool on a running MCP server.
+ */
+export async function callTool(serverId, toolName, args) {
+    const server = servers.get(serverId);
+    if (!server) {
+        throw new Error(`MCP server "${serverId}" is not running`);
+    }
+    const result = await server.client.callTool({
+        name: toolName,
+        arguments: args,
+    });
+    // Extract text from content blocks
+    if (result.content && Array.isArray(result.content)) {
+        return result.content
+            .map((block) => {
+            if (block.type === "text")
+                return block.text || "";
+            return JSON.stringify(block);
+        })
+            .join("\n");
+    }
+    return JSON.stringify(result);
+}
+/**
+ * List tools for a running MCP server.
+ */
+export function listTools(serverId) {
+    const server = servers.get(serverId);
+    if (!server) {
+        return JSON.stringify({ serverId, running: false, tools: [] });
+    }
+    return JSON.stringify({
+        serverId,
+        running: true,
+        tools: server.tools,
+    });
+}
+/**
+ * Get status of all running MCP servers.
+ */
+export function getStatus() {
+    const statuses = Array.from(servers.entries()).map(([id, server]) => ({
+        serverId: id,
+        running: true,
+        pid: server.pid,
+        toolCount: server.tools.length,
+    }));
+    return JSON.stringify({ servers: statuses });
+}
+/**
+ * Stop all running MCP servers. Called during daemon shutdown.
+ */
+export async function stopAll() {
+    const ids = Array.from(servers.keys());
+    for (const id of ids) {
+        await stopServer(id);
+    }
+}

package/dist/daemon.d.ts

@@ -22,7 +22,7 @@ export declare class Daemon {
     /** Start the daemon. */
     start(): void;
     /** Stop the daemon gracefully. */
-    stop(): void;
+    stop(): Promise<void>;
     private handleStatus;
     private handleMessage;
     private handleNeedsPairing;

package/dist/daemon.js

@@ -17,6 +17,7 @@ import { DaemonConnection } from "./connection.js";
 import { ensureIdentity, getWorkspaceRoot, setWorkspaceRoot } from "./identity.js";
 import { generatePairCode, displayPairCode } from "./pairing.js";
 import { dispatch } from "./dispatcher.js";
+import { stopAll as stopAllMcpServers } from "./capabilities/mcp.js";
 import { getLogFilePath } from "./logger.js";
 // Read version from package.json so it stays in sync automatically
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -64,8 +65,9 @@ export class Daemon {
         this.connection.connect();
     }
     /** Stop the daemon gracefully. */
-    stop() {
+    async stop() {
         console.log("\n  Shutting down...");
+        await stopAllMcpServers();
         this.connection.disconnect();
     }
     handleStatus(status) {

package/dist/dispatcher.js

@@ -11,6 +11,7 @@ import * as fsCap from "./capabilities/fs.js";
 import * as gitCap from "./capabilities/git.js";
 import * as shellCap from "./capabilities/shell.js";
 import * as skillsCap from "./capabilities/skills.js";
+import * as mcpCap from "./capabilities/mcp.js";
 /**
  * Validate that a given path is within the workspace root.
  * Prevents path traversal attacks.
@@ -77,6 +78,12 @@ async function dispatchInner(command, payload, connection) {
                 : getWorkspaceRoot();
             return fsCap.listRecursive(target, payload.depth);
         }
+        case "fs:find": {
+            const target = payload.path
+                ? validatePath(payload.path)
+                : getWorkspaceRoot();
+            return fsCap.findFiles(target, payload.depth);
+        }
         // ─── Workspace ──────────────────────────────────────
         case "workspace:get": {
             return { workspaceRoot: getWorkspaceRoot() };
@@ -133,6 +140,27 @@ async function dispatchInner(command, payload, connection) {
                 throw new Error("No workspace root configured.");
             return skillsCap.seedSkills(workspace);
         }
+        // ─── MCP Servers ─────────────────────────────────────
+        case "mcp:start": {
+            return mcpCap.startServer({
+                id: payload.id,
+                command: payload.command,
+                args: payload.args,
+                env: payload.env,
+            });
+        }
+        case "mcp:stop": {
+            return mcpCap.stopServer(payload.serverId);
+        }
+        case "mcp:call": {
+            return mcpCap.callTool(payload.serverId, payload.toolName, payload.args || {});
+        }
+        case "mcp:tools": {
+            return mcpCap.listTools(payload.serverId);
+        }
+        case "mcp:status": {
+            return mcpCap.getStatus();
+        }
         default:
             throw new Error(`Unknown command: ${command}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aem-ext-daemon",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Local daemon for AEM Extension Builder — connects your machine to the cloud UI",
   "type": "module",
   "bin": {
@@ -15,6 +15,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "conf": "^13.0.1",
     "qrcode-terminal": "^0.12.0",
     "ws": "^8.18.0"