aem-ext-daemon 0.3.8 → 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/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 { getLogFilePath } from "./logger.js";
 // Read version from package.json so it stays in sync automatically
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkgPath = path.resolve(__dirname, "..", "package.json");
@@ -57,6 +58,7 @@ export class Daemon {
         if (workspace) {
             console.log(`  Workspace:  ${workspace}`);
         }
+        console.log(`  Log file:   ${getLogFilePath()}`);
         console.log("");
         console.log("  Connecting...");
         this.connection.connect();

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/dist/logger.d.ts

@@ -1,8 +1,7 @@
 /**
- * Daemon logger — writes timestamped entries to a log file in the project directory.
+ * Daemon logger — writes timestamped entries to a log file and the terminal.
  *
- * Log file location: <workspaceRoot>/.daemon.log
- * Also prints key events to the daemon terminal (stdout).
+ * Log file: ~/.adobe-ext-builder/daemon.log (always available, regardless of workspace config)
  */
 /** Log a command being dispatched. */
 export declare function logCommand(command: string, payload: Record<string, unknown>): void;
@@ -12,3 +11,5 @@ export declare function logResult(command: string, result: string, durationMs: n
 export declare function logError(command: string, error: string, durationMs: number): void;
 /** Log a general info message. */
 export declare function logInfo(message: string): void;
+/** Return the log file path for display purposes. */
+export declare function getLogFilePath(): string;

package/dist/logger.js

@@ -1,35 +1,19 @@
 /**
- * Daemon logger — writes timestamped entries to a log file in the project directory.
+ * Daemon logger — writes timestamped entries to a log file and the terminal.
  *
- * Log file location: <workspaceRoot>/.daemon.log
- * Also prints key events to the daemon terminal (stdout).
+ * Log file: ~/.adobe-ext-builder/daemon.log (always available, regardless of workspace config)
  */
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
-import { getWorkspaceRoot } from "./identity.js";
+const LOG_DIR = path.join(os.homedir(), ".adobe-ext-builder");
+const LOG_PATH = path.join(LOG_DIR, "daemon.log");
 let logStream = null;
-let currentLogPath = null;
-function getLogPath() {
-    const root = getWorkspaceRoot();
-    if (!root)
-        return null;
-    return path.join(root, ".daemon.log");
-}
 function ensureStream() {
-    const logPath = getLogPath();
-    if (!logPath)
-        return null;
-    // Re-open if workspace changed
-    if (logPath !== currentLogPath) {
-        logStream?.end();
-        logStream = null;
-        currentLogPath = null;
-    }
     if (!logStream) {
         try {
-            fs.mkdirSync(path.dirname(logPath), { recursive: true });
-            logStream = fs.createWriteStream(logPath, { flags: "a" });
-            currentLogPath = logPath;
+            fs.mkdirSync(LOG_DIR, { recursive: true });
+            logStream = fs.createWriteStream(LOG_PATH, { flags: "a" });
         }
         catch {
             return null;
@@ -49,7 +33,7 @@ export function logCommand(command, payload) {
 }
 /** Log a command result (success). */
 export function logResult(command, result, durationMs) {
-    const preview = result.length > 200 ? result.slice(0, 200) + "..." : result;
+    const preview = result.length > 500 ? result.slice(0, 500) + "..." : result;
     const line = `[${ts()}] OK   ${command}  (${durationMs}ms)  ${preview}`;
     const stream = ensureStream();
     stream?.write(line + "\n");
@@ -60,7 +44,9 @@ export function logError(command, error, durationMs) {
     const line = `[${ts()}] ERR  ${command}  (${durationMs}ms)  ${error}`;
     const stream = ensureStream();
     stream?.write(line + "\n");
-    console.log(`  ✗  ${command} (${durationMs}ms): ${error.slice(0, 100)}`);
+    // Print the FULL error to the terminal so users can diagnose issues
+    console.log(`  ✗  ${command} (${durationMs}ms)`);
+    console.log(`     Error: ${error}`);
 }
 /** Log a general info message. */
 export function logInfo(message) {
@@ -68,3 +54,7 @@ export function logInfo(message) {
     const stream = ensureStream();
     stream?.write(line + "\n");
 }
+/** Return the log file path for display purposes. */
+export function getLogFilePath() {
+    return LOG_PATH;
+}

package/package.json

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