aem-ext-daemon 0.4.1 → 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/capabilities/shell.d.ts

@@ -18,13 +18,11 @@ export declare function checkAio(): string;
  */
 export declare function runAio(args: string[], cwd: string, requestId: string, connection: DaemonConnection): Promise<string>;
 /**
- * Start an interactive command. Collects output until the process goes
- * quiet (waiting for user input) or exits, then returns what it has.
- * Does NOT set CI=true or TERM=dumb so prompts render normally.
+ * Start an interactive command by opening a real terminal window on the
+ * user's machine. Returns immediately with instructions — the agent
+ * should poll for completion (e.g., check for .aio file).
+ *
+ * This is needed because inquirer-based CLIs (like `aio app create`)
+ * require a real TTY for their interactive prompts.
  */
 export declare function spawnInteractive(command: string, cwd: string): Promise<string>;
-/**
- * Send input to the active interactive process. Waits for the process
- * to produce more output (or go quiet again), then returns the new output.
- */
-export declare function writeToProcess(input: string): Promise<string>;

package/dist/capabilities/shell.js

@@ -9,6 +9,7 @@
 import { execSync, spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
+import path from "node:path";
 const EXEC_TIMEOUT = 120_000; // 2 minutes
 const MAX_BUFFER = 5 * 1024 * 1024; // 5MB
 /** Resolve the user's login shell (falls back to /bin/sh). */
@@ -146,154 +147,70 @@ export function runAio(args, cwd, requestId, connection) {
     });
 }
 // ─── Interactive process support ────────────────────────────
-// Allows commands that need user input (like `aio app create`)
-// to run through the chat UI.
-/** The single active interactive process (one per daemon). */
-let activeProcess = null;
-/** How long to wait for more output before assuming the process is waiting for input. */
-const SILENCE_TIMEOUT = 3_000;
-/** Strip ANSI escape codes from PTY output for clean text. */
-function stripAnsi(text) {
-    // eslint-disable-next-line no-control-regex
-    return text.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "")
-        .replace(/\r\n/g, "\n")
-        .replace(/\r/g, "\n");
-}
+// Opens interactive commands in a real terminal window since
+// inquirer-based CLIs require a TTY for their prompts.
 /**
- * Start an interactive command. Collects output until the process goes
- * quiet (waiting for user input) or exits, then returns what it has.
- * Does NOT set CI=true or TERM=dumb so prompts render normally.
+ * Start an interactive command by opening a real terminal window on the
+ * user's machine. Returns immediately with instructions — the agent
+ * should poll for completion (e.g., check for .aio file).
+ *
+ * This is needed because inquirer-based CLIs (like `aio app create`)
+ * require a real TTY for their interactive prompts.
  */
 export function spawnInteractive(command, cwd) {
-    // Kill any existing interactive process
-    if (activeProcess && !activeProcess.done) {
-        activeProcess.child.kill("SIGTERM");
-    }
-    activeProcess = null;
     if (!fs.existsSync(cwd)) {
         fs.mkdirSync(cwd, { recursive: true });
     }
-    return new Promise((resolve) => {
-        // Use `script` to create a pseudo-TTY so inquirer-based CLIs
-        // (like aio app create) render their prompts properly.
-        // macOS: script -q /dev/null sh -c "<command>"
-        // Linux: script -qec "<command>" /dev/null
-        const isMac = os.platform() === "darwin";
-        const spawnCmd = isMac ? "script" : "script";
-        const spawnArgs = isMac
-            ? ["-q", "/dev/null", "sh", "-c", command]
-            : ["-qec", command, "/dev/null"];
-        const child = spawn(spawnCmd, spawnArgs, {
-            cwd,
-            env: {
-                ...getEnhancedEnv(),
-                // Do NOT set CI or TERM=dumb — we want interactive prompts
-                TERM: "xterm-256color",
-                COLUMNS: "120",
-                LINES: "40",
-            },
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        const proc = { child, buffer: "", done: false, exitCode: null };
-        activeProcess = proc;
-        let silenceTimer;
-        const flushAndReturn = () => {
-            const output = stripAnsi(proc.buffer);
-            proc.buffer = "";
-            resolve(output || "(no output)");
-        };
-        const resetTimer = () => {
-            clearTimeout(silenceTimer);
-            silenceTimer = setTimeout(() => {
-                if (!proc.done) {
-                    // Process went quiet — probably waiting for input
-                    flushAndReturn();
-                }
-            }, SILENCE_TIMEOUT);
-        };
-        child.stdout?.on("data", (chunk) => {
-            proc.buffer += chunk.toString();
-            resetTimer();
-        });
-        child.stderr?.on("data", (chunk) => {
-            proc.buffer += chunk.toString();
-            resetTimer();
-        });
-        child.on("close", (code) => {
-            proc.done = true;
-            proc.exitCode = code;
-            clearTimeout(silenceTimer);
-            proc.buffer += `\n[Process exited with code ${code ?? 1}]`;
-            flushAndReturn();
-        });
-        child.on("error", (err) => {
-            proc.done = true;
-            clearTimeout(silenceTimer);
-            proc.buffer += `\n[Error: ${err.message}]`;
-            flushAndReturn();
-        });
-        // Start the silence timer
-        resetTimer();
-        // Overall timeout: 5 minutes
-        setTimeout(() => {
-            if (!proc.done) {
-                child.kill("SIGTERM");
-                proc.done = true;
-                proc.buffer += "\n[Timed out after 5 minutes]";
-                flushAndReturn();
+    const platform = os.platform();
+    if (platform === "darwin") {
+        // macOS: write a temp script and open it in Terminal.app
+        const scriptPath = path.join(os.tmpdir(), `aio-interactive-${Date.now()}.sh`);
+        fs.writeFileSync(scriptPath, [
+            "#!/bin/bash",
+            `cd "${cwd}"`,
+            command,
+            'echo ""',
+            'echo "✓ Done! You can close this terminal window."',
+            'read -p "Press Enter to close..."',
+        ].join("\n"), { mode: 0o755 });
+        try {
+            execSync(`open -a Terminal.app "${scriptPath}"`, {
+                encoding: "utf-8",
+                timeout: 10_000,
+            });
+            return Promise.resolve(`[INTERACTIVE] Opened a new Terminal window to run: ${command}\n` +
+                `Working directory: ${cwd}\n\n` +
+                `The user needs to complete the interactive prompts in that Terminal window.\n` +
+                `After they finish, check for the .aio file to confirm: ls -la .aio\n` +
+                `DO NOT proceed until the .aio file exists.`);
+        }
+        catch (err) {
+            return Promise.resolve(`Error opening Terminal: ${err.message}`);
+        }
+    }
+    if (platform === "linux") {
+        // Try common Linux terminal emulators
+        const terminals = ["gnome-terminal", "xfce4-terminal", "konsole", "xterm"];
+        for (const term of terminals) {
+            try {
+                execSync(`which ${term}`, { encoding: "utf-8" });
+                execSync(`${term} -- bash -c 'cd "${cwd}" && ${command} && echo Done && read -p "Press Enter..."'`, {
+                    encoding: "utf-8",
+                    timeout: 10_000,
+                });
+                return Promise.resolve(`[INTERACTIVE] Opened ${term} to run: ${command}\n` +
+                    `Working directory: ${cwd}\n\n` +
+                    `The user needs to complete the interactive prompts in that terminal.\n` +
+                    `After they finish, check for the .aio file: ls -la .aio`);
             }
-        }, 300_000);
-    });
-}
-/**
- * Send input to the active interactive process. Waits for the process
- * to produce more output (or go quiet again), then returns the new output.
- */
-export function writeToProcess(input) {
-    if (!activeProcess || activeProcess.done) {
-        return Promise.resolve(activeProcess
-            ? `[Process already exited with code ${activeProcess.exitCode}]`
-            : "[No interactive process running. Use interactive_bash to start one.]");
+            catch {
+                continue;
+            }
+        }
     }
-    const proc = activeProcess;
-    return new Promise((resolve) => {
-        let silenceTimer;
-        let resolved = false;
-        const finish = (output) => {
-            if (resolved)
-                return;
-            resolved = true;
-            clearTimeout(silenceTimer);
-            proc.child.stdout?.off("data", onData);
-            proc.child.stderr?.off("data", onData);
-            proc.child.off("close", onClose);
-            resolve(output);
-        };
-        const resetTimer = () => {
-            clearTimeout(silenceTimer);
-            silenceTimer = setTimeout(() => {
-                if (!proc.done) {
-                    const output = stripAnsi(proc.buffer);
-                    proc.buffer = "";
-                    finish(output || "(waiting for input...)");
-                }
-            }, SILENCE_TIMEOUT);
-        };
-        const onData = () => resetTimer();
-        const onClose = () => {
-            // Small delay to capture any final output
-            setTimeout(() => {
-                const output = stripAnsi(proc.buffer);
-                proc.buffer = "";
-                finish(output || "(no output)");
-            }, 200);
-        };
-        proc.child.stdout?.on("data", onData);
-        proc.child.stderr?.on("data", onData);
-        proc.child.once("close", onClose);
-        // Write the input
-        proc.child.stdin?.write(input + "\n");
-        // Start silence timer
-        resetTimer();
-    });
+    // Fallback: tell the user to run it manually
+    return Promise.resolve(`[INTERACTIVE] This command requires interactive input and must be run in a terminal.\n\n` +
+        `Please ask the user to open their terminal and run:\n\n` +
+        `  cd "${cwd}"\n  ${command}\n\n` +
+        `After they finish, check for the .aio file: ls -la .aio`);
 }

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() };
@@ -119,9 +126,7 @@ async function dispatchInner(command, payload, connection) {
                 : getWorkspaceRoot();
             return shellCap.spawnInteractive(payload.command, cwd);
         }
-        case "shell:stdin": {
-            return shellCap.writeToProcess(payload.input);
-        }
+        // shell:stdin removed — interactive commands now open a terminal window
         // ─── Skills ────────────────────────────────────────
         case "skills:sync": {
             const workspace = getWorkspaceRoot();
@@ -135,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.1",
+  "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"