aem-ext-daemon 0.3.9 → 0.4.0

package/dist/capabilities/shell.d.ts

@@ -3,6 +3,8 @@
  *
  * aio:run streams stdout/stderr back through the WebSocket.
  * shell:exec runs a command and returns the full output.
+ * shell:spawn starts an interactive process (for commands that need user input).
+ * shell:stdin sends input to the active interactive process.
  */
 import type { DaemonConnection } from "../connection.js";
 /** Run a shell command synchronously and return stdout + stderr. */
@@ -15,3 +17,14 @@ export declare function checkAio(): string;
  * then returns the exit code.
  */
 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.
+ */
+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

@@ -3,6 +3,8 @@
  *
  * aio:run streams stdout/stderr back through the WebSocket.
  * shell:exec runs a command and returns the full output.
+ * shell:spawn starts an interactive process (for commands that need user input).
+ * shell:stdin sends input to the active interactive process.
  */
 import { execSync, spawn } from "node:child_process";
 import fs from "node:fs";
@@ -143,3 +145,139 @@ export function runAio(args, cwd, requestId, connection) {
         }, 300_000);
     });
 }
+// ─── 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;
+/**
+ * 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.
+ */
+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();
+            }
+        }, 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.]");
+    }
+    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();
+    });
+}

package/dist/dispatcher.js

@@ -113,6 +113,15 @@ async function dispatchInner(command, payload, connection) {
                 : getWorkspaceRoot();
             return shellCap.exec(payload.command, cwd);
         }
+        case "shell:spawn": {
+            const cwd = payload.cwd
+                ? validatePath(payload.cwd)
+                : getWorkspaceRoot();
+            return shellCap.spawnInteractive(payload.command, cwd);
+        }
+        case "shell:stdin": {
+            return shellCap.writeToProcess(payload.input);
+        }
         // ─── Skills ────────────────────────────────────────
         case "skills:sync": {
             const workspace = getWorkspaceRoot();

package/package.json

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