aem-ext-daemon 0.3.6 → 0.3.8

package/dist/capabilities/shell.js

@@ -5,6 +5,7 @@
  * shell:exec runs a command and returns the full output.
  */
 import { execSync, spawn } from "node:child_process";
+import fs from "node:fs";
 import os from "node:os";
 const EXEC_TIMEOUT = 120_000; // 2 minutes
 const MAX_BUFFER = 5 * 1024 * 1024; // 5MB
@@ -39,6 +40,11 @@ function getEnhancedEnv() {
 export function exec(command, cwd) {
     if (!command)
         throw new Error("command is required");
+    // Ensure the working directory exists locally — the server may have
+    // computed the path but only created it on its own filesystem.
+    if (!fs.existsSync(cwd)) {
+        fs.mkdirSync(cwd, { recursive: true });
+    }
     // Redirect stderr to stdout so we capture everything, and ensure
     // no interactive prompts leak to the daemon terminal.
     // Also set CI=true and TERM=dumb so CLIs skip interactive prompts.
@@ -84,6 +90,9 @@ export function checkAio() {
  */
 export function runAio(args, cwd, requestId, connection) {
     return new Promise((resolve, reject) => {
+        if (!fs.existsSync(cwd)) {
+            fs.mkdirSync(cwd, { recursive: true });
+        }
         const child = spawn("aio", args, {
             cwd,
             shell: getUserShell(),

package/dist/dispatcher.js

@@ -6,6 +6,7 @@
  */
 import path from "node:path";
 import { getWorkspaceRoot, setWorkspaceRoot } from "./identity.js";
+import { logCommand, logResult, logError } from "./logger.js";
 import * as fsCap from "./capabilities/fs.js";
 import * as gitCap from "./capabilities/git.js";
 import * as shellCap from "./capabilities/shell.js";
@@ -29,6 +30,21 @@ function validatePath(targetPath) {
  * Dispatch a command to the appropriate capability handler.
  */
 export async function dispatch(command, payload, connection) {
+    logCommand(command, payload);
+    const start = Date.now();
+    try {
+        const result = await dispatchInner(command, payload, connection);
+        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+        logResult(command, resultStr, Date.now() - start);
+        return result;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logError(command, message, Date.now() - start);
+        throw err;
+    }
+}
+async function dispatchInner(command, payload, connection) {
     switch (command) {
         // ─── Filesystem ─────────────────────────────────────
         case "fs:roots": {

package/dist/logger.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Daemon logger — writes timestamped entries to a log file in the project directory.
+ *
+ * Log file location: <workspaceRoot>/.daemon.log
+ * Also prints key events to the daemon terminal (stdout).
+ */
+/** Log a command being dispatched. */
+export declare function logCommand(command: string, payload: Record<string, unknown>): void;
+/** Log a command result (success). */
+export declare function logResult(command: string, result: string, durationMs: number): void;
+/** Log a command error. */
+export declare function logError(command: string, error: string, durationMs: number): void;
+/** Log a general info message. */
+export declare function logInfo(message: string): void;

package/dist/logger.js

@@ -0,0 +1,70 @@
+/**
+ * Daemon logger — writes timestamped entries to a log file in the project directory.
+ *
+ * Log file location: <workspaceRoot>/.daemon.log
+ * Also prints key events to the daemon terminal (stdout).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { getWorkspaceRoot } from "./identity.js";
+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;
+        }
+        catch {
+            return null;
+        }
+    }
+    return logStream;
+}
+function ts() {
+    return new Date().toISOString();
+}
+/** Log a command being dispatched. */
+export function logCommand(command, payload) {
+    const line = `[${ts()}] CMD  ${command}  ${JSON.stringify(payload)}`;
+    const stream = ensureStream();
+    stream?.write(line + "\n");
+    console.log(`  ▶  ${command}`);
+}
+/** Log a command result (success). */
+export function logResult(command, result, durationMs) {
+    const preview = result.length > 200 ? result.slice(0, 200) + "..." : result;
+    const line = `[${ts()}] OK   ${command}  (${durationMs}ms)  ${preview}`;
+    const stream = ensureStream();
+    stream?.write(line + "\n");
+    console.log(`  ✓  ${command} (${durationMs}ms)`);
+}
+/** Log a command error. */
+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)}`);
+}
+/** Log a general info message. */
+export function logInfo(message) {
+    const line = `[${ts()}] INFO ${message}`;
+    const stream = ensureStream();
+    stream?.write(line + "\n");
+}

package/package.json

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