aem-ext-daemon 0.4.0 → 0.4.2

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,138 +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;
+// 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) => {
-        const child = spawn(command, [], {
-            cwd,
-            shell: getUserShell(),
-            env: {
-                ...getEnhancedEnv(),
-                // Do NOT set CI or TERM=dumb — we want interactive prompts
-                FORCE_COLOR: "0",
-                NO_COLOR: "1",
-            },
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        const proc = { child, buffer: "", done: false, exitCode: null };
-        activeProcess = proc;
-        let silenceTimer;
-        const flushAndReturn = () => {
-            const output = 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 = 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 = 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/dispatcher.js

@@ -119,9 +119,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aem-ext-daemon",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Local daemon for AEM Extension Builder — connects your machine to the cloud UI",
   "type": "module",
   "bin": {