very-happy-cli 0.2.159 → 0.2.160

package/dist/registerCommonHandlers-DskirN-_.cjs

@@ -0,0 +1,538 @@
+'use strict';
+
+var logger = require('./logger-CS0mw3fa.cjs');
+var child_process = require('child_process');
+var util = require('util');
+var fs = require('fs/promises');
+var crypto = require('crypto');
+var path = require('path');
+var spawn = require('cross-spawn');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var os = require('os');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+
+function run$1(args, options) {
+  const RUNNER_PATH = path.resolve(path.join(projectPath.projectPath(), "scripts", "ripgrep_launcher.cjs"));
+  return new Promise((resolve2, reject) => {
+    const child = spawn.spawn("node", [RUNNER_PATH, JSON.stringify(args)], {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: options?.cwd,
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve2({
+        exitCode: code || 0,
+        stdout,
+        stderr
+      });
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+function getBinaryPath() {
+  const platformName = os.platform();
+  const binaryName = platformName === "win32" ? "difft.exe" : "difft";
+  return path.resolve(path.join(projectPath.projectPath(), "tools", "unpacked", binaryName));
+}
+function run(args, options) {
+  const binaryPath = getBinaryPath();
+  return new Promise((resolve2, reject) => {
+    const child = child_process.spawn(binaryPath, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: options?.cwd,
+      windowsHide: true,
+      env: {
+        ...process.env,
+        // Force color output when needed
+        FORCE_COLOR: "1"
+      }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve2({
+        exitCode: code || 0,
+        stdout,
+        stderr
+      });
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+function validatePath(targetPath, workingDirectory) {
+  const resolvedTarget = path.resolve(workingDirectory, targetPath);
+  const resolvedWorkingDir = path.resolve(workingDirectory);
+  if (!resolvedTarget.startsWith(resolvedWorkingDir + path.sep) && resolvedTarget !== resolvedWorkingDir) {
+    return {
+      valid: false,
+      resolvedPath: resolvedTarget,
+      error: `Access denied: Path '${targetPath}' is outside the working directory`
+    };
+  }
+  return { valid: true, resolvedPath: resolvedTarget };
+}
+
+const MAX_USER_UPLOAD_BYTES = 8 * 1024 * 1024;
+const MAX_USER_UPLOAD_CHUNK_BYTES = 96 * 1024;
+const MAX_ACTIVE_UPLOADS = 8;
+const UPLOAD_TTL_MS = 10 * 60 * 1e3;
+function safeSegment(value, fallback, maxLength) {
+  const sanitized = (value || fallback).replace(/[^\w.\-]+/g, "_").slice(0, maxLength) || fallback;
+  return sanitized === "." || sanitized === ".." ? fallback : sanitized;
+}
+function safeFileName(value) {
+  const basename = (value || "file").split(/[/\\]/).pop() || "file";
+  return safeSegment(basename, "file", 200);
+}
+function uniqueFileName(name, token) {
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? `${name.slice(0, dot)}-${token}${name.slice(dot)}` : `${name}-${token}`;
+}
+function decodeUploadBase64(content, maxBytes) {
+  const maxEncodedLength = Math.ceil(maxBytes / 3) * 4;
+  if (content.length > maxEncodedLength || content.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(content)) {
+    throw new Error("Invalid upload payload");
+  }
+  const buffer = Buffer.from(content, "base64");
+  if (buffer.length > maxBytes || buffer.toString("base64") !== content) {
+    throw new Error("Invalid upload payload");
+  }
+  return buffer;
+}
+function validateUploadId(value) {
+  if (!/^[A-Za-z0-9_-]{8,80}$/.test(value)) {
+    throw new Error("Invalid upload id");
+  }
+  return value;
+}
+function defaultPathQuoteStyle() {
+  if (process.platform !== "win32") return "posix";
+  const shell = (process.env.COMSPEC || "powershell.exe").toLowerCase();
+  return shell.includes("powershell") || shell.includes("pwsh") ? "powershell" : "cmd";
+}
+function createUploadFileHandlers(happyHomeDir, now = Date.now, pathQuoteStyle = defaultPathQuoteStyle()) {
+  const active = /* @__PURE__ */ new Map();
+  let operationQueue = Promise.resolve();
+  const serialize = (handler) => (data) => {
+    const result = operationQueue.then(() => handler(data), () => handler(data));
+    operationQueue = result.then(() => void 0, () => void 0);
+    return result;
+  };
+  const removeActive = async (uploadId) => {
+    const upload = active.get(uploadId);
+    active.delete(uploadId);
+    if (upload) await fs.unlink(upload.tempPath).catch(() => {
+    });
+  };
+  const sweepExpired = async () => {
+    const cutoff = now() - UPLOAD_TTL_MS;
+    await Promise.all(
+      [...active.entries()].filter(([, upload]) => upload.touchedAt < cutoff).map(([uploadId]) => removeActive(uploadId))
+    );
+  };
+  const sweepExpiredFiles = async (dir) => {
+    const cutoff = now() - UPLOAD_TTL_MS;
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    await Promise.all(entries.map(async (entry) => {
+      if (!entry.isFile() || !/^\..+\.[A-Za-z0-9_-]{8,80}\.part$/.test(entry.name)) return;
+      const path$1 = path.join(dir, entry.name);
+      const fileStat = await fs.stat(path$1).catch(() => null);
+      if (fileStat && fileStat.mtimeMs < cutoff) await fs.unlink(path$1).catch(() => {
+      });
+    }));
+  };
+  const uploadFileUnlocked = async (data) => {
+    let tempPath = null;
+    try {
+      const buffer = decodeUploadBase64(data.content, MAX_USER_UPLOAD_BYTES);
+      const dir = path.join(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
+      await fs.mkdir(dir, { recursive: true });
+      const name = safeFileName(data.name);
+      const token = crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+      const target = path.join(dir, uniqueFileName(name, token));
+      tempPath = path.join(dir, `.${name}.legacy_${crypto.randomUUID().replace(/-/g, "")}.part`);
+      await fs.writeFile(tempPath, buffer, { flag: "wx" });
+      await fs.rename(tempPath, target);
+      tempPath = null;
+      return { success: true, path: target, pathQuoteStyle, size: buffer.length };
+    } catch (error) {
+      if (tempPath) await fs.unlink(tempPath).catch(() => {
+      });
+      return { success: false, error: error instanceof Error ? error.message : "Failed to upload file" };
+    }
+  };
+  const uploadFileChunkUnlocked = async (data) => {
+    try {
+      await sweepExpired();
+      const uploadId = validateUploadId(data.uploadId);
+      if (data.action === "start") {
+        if (!Number.isSafeInteger(data.totalSize) || data.totalSize < 0 || data.totalSize > MAX_USER_UPLOAD_BYTES) {
+          throw new Error(`File exceeds the ${MAX_USER_UPLOAD_BYTES / 1024 / 1024} MB upload limit`);
+        }
+        if (active.has(uploadId)) throw new Error("Upload id is already active");
+        if (active.size >= MAX_ACTIVE_UPLOADS) throw new Error("Too many active uploads");
+        const dir = path.join(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
+        await fs.mkdir(dir, { recursive: true });
+        await sweepExpiredFiles(dir);
+        const name = safeFileName(data.name);
+        const targetPath = path.join(dir, uniqueFileName(name, crypto.randomUUID().replace(/-/g, "").slice(0, 12)));
+        const tempPath = path.join(dir, `.${name}.${uploadId}.part`);
+        await fs.writeFile(tempPath, Buffer.alloc(0), { flag: "wx" });
+        active.set(uploadId, { tempPath, targetPath, totalSize: data.totalSize, received: 0, touchedAt: now() });
+        return { success: true, size: 0 };
+      }
+      if (data.action === "abort") {
+        const upload2 = active.get(uploadId);
+        if (!upload2) return { success: true, size: 0 };
+        await removeActive(uploadId);
+        return { success: true, size: upload2.received };
+      }
+      const upload = active.get(uploadId);
+      if (!upload) throw new Error("Upload is not active or has expired");
+      if (data.action === "append") {
+        if (!Number.isSafeInteger(data.offset) || data.offset !== upload.received) {
+          throw new Error("Upload chunk is out of order");
+        }
+        const chunk = decodeUploadBase64(data.content, MAX_USER_UPLOAD_CHUNK_BYTES);
+        if (upload.received + chunk.length > upload.totalSize) {
+          throw new Error("Upload exceeds declared size");
+        }
+        await fs.appendFile(upload.tempPath, chunk);
+        upload.received += chunk.length;
+        upload.touchedAt = now();
+        return { success: true, size: upload.received };
+      }
+      if (data.action !== "finish") throw new Error("Invalid upload action");
+      if (upload.received !== upload.totalSize) throw new Error("Upload is incomplete");
+      const tempStat = await fs.stat(upload.tempPath);
+      if (tempStat.size !== upload.totalSize) throw new Error("Upload size verification failed");
+      await fs.rename(upload.tempPath, upload.targetPath);
+      active.delete(uploadId);
+      return { success: true, path: upload.targetPath, pathQuoteStyle, size: upload.totalSize };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : "Failed to upload file" };
+    }
+  };
+  return {
+    uploadFile: serialize(uploadFileUnlocked),
+    uploadFileChunk: serialize(uploadFileChunkUnlocked)
+  };
+}
+
+const execAsync = util.promisify(child_process.exec);
+function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
+  rpcHandlerManager.registerHandler("bash", async (data) => {
+    logger.logger.debug("Shell command request:", data.command);
+    if (data.cwd && data.cwd !== "/") {
+      const validation = validatePath(data.cwd, workingDirectory);
+      if (!validation.valid) {
+        return { success: false, error: validation.error };
+      }
+      data.cwd = validation.resolvedPath;
+    }
+    try {
+      const options = {
+        cwd: data.cwd === "/" ? void 0 : data.cwd,
+        timeout: data.timeout || 3e4,
+        // Default 30 seconds timeout
+        windowsHide: true
+        // Prevent cmd.exe popup on Windows for every RPC bash call
+      };
+      logger.logger.debug("Shell command executing...", { cwd: options.cwd, timeout: options.timeout });
+      const { stdout, stderr } = await execAsync(data.command, options);
+      logger.logger.debug("Shell command executed, processing result...");
+      const result = {
+        success: true,
+        stdout: stdout ? stdout.toString() : "",
+        stderr: stderr ? stderr.toString() : "",
+        exitCode: 0
+      };
+      logger.logger.debug("Shell command result:", {
+        success: true,
+        exitCode: 0,
+        stdoutLen: result.stdout.length,
+        stderrLen: result.stderr.length
+      });
+      return result;
+    } catch (error) {
+      const execError = error;
+      if (execError.code === "ETIMEDOUT" || execError.killed) {
+        const result2 = {
+          success: false,
+          stdout: execError.stdout || "",
+          stderr: execError.stderr || "",
+          exitCode: typeof execError.code === "number" ? execError.code : -1,
+          error: "Command timed out"
+        };
+        logger.logger.debug("Shell command timed out:", {
+          success: false,
+          exitCode: result2.exitCode,
+          error: "Command timed out"
+        });
+        return result2;
+      }
+      const result = {
+        success: false,
+        stdout: execError.stdout ? execError.stdout.toString() : "",
+        stderr: execError.stderr ? execError.stderr.toString() : execError.message || "Command failed",
+        exitCode: typeof execError.code === "number" ? execError.code : 1,
+        error: execError.message || "Command failed"
+      };
+      logger.logger.debug("Shell command failed:", {
+        success: false,
+        exitCode: result.exitCode,
+        error: result.error,
+        stdoutLen: result.stdout.length,
+        stderrLen: result.stderr.length
+      });
+      return result;
+    }
+  });
+  rpcHandlerManager.registerHandler("readFile", async (data) => {
+    logger.logger.debug("Read file request:", data.path);
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    try {
+      const buffer = await fs.readFile(validation.resolvedPath);
+      const content = buffer.toString("base64");
+      return { success: true, content };
+    } catch (error) {
+      logger.logger.debug("Failed to read file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
+    }
+  });
+  rpcHandlerManager.registerHandler("writeFile", async (data) => {
+    logger.logger.debug("Write file request:", data.path);
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    try {
+      if (data.expectedHash !== null && data.expectedHash !== void 0) {
+        try {
+          const existingBuffer = await fs.readFile(validation.resolvedPath);
+          const existingHash = crypto.createHash("sha256").update(existingBuffer).digest("hex");
+          if (existingHash !== data.expectedHash) {
+            return {
+              success: false,
+              error: `File hash mismatch. Expected: ${data.expectedHash}, Actual: ${existingHash}`
+            };
+          }
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+          return {
+            success: false,
+            error: "File does not exist but hash was provided"
+          };
+        }
+      } else {
+        try {
+          await fs.stat(validation.resolvedPath);
+          return {
+            success: false,
+            error: "File already exists but was expected to be new"
+          };
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      }
+      const buffer = Buffer.from(data.content, "base64");
+      await fs.writeFile(validation.resolvedPath, buffer);
+      const hash = crypto.createHash("sha256").update(buffer).digest("hex");
+      return { success: true, hash };
+    } catch (error) {
+      logger.logger.debug("Failed to write file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
+    }
+  });
+  const uploadHandlers = createUploadFileHandlers(configuration.configuration.happyHomeDir);
+  rpcHandlerManager.registerHandler("uploadFile", uploadHandlers.uploadFile);
+  rpcHandlerManager.registerHandler("uploadFileChunk", uploadHandlers.uploadFileChunk);
+  rpcHandlerManager.registerHandler("listDirectory", async (data) => {
+    logger.logger.debug("List directory request:", data.path);
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    try {
+      const directoryPath = validation.resolvedPath;
+      const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+      const directoryEntries = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = path.join(directoryPath, entry.name);
+          let type = "other";
+          let size;
+          let modified;
+          if (entry.isDirectory()) {
+            type = "directory";
+          } else if (entry.isFile()) {
+            type = "file";
+          }
+          try {
+            const stats = await fs.stat(fullPath);
+            size = stats.size;
+            modified = stats.mtime.getTime();
+          } catch (error) {
+            logger.logger.debug(`Failed to stat ${fullPath}:`, error);
+          }
+          return {
+            name: entry.name,
+            type,
+            size,
+            modified
+          };
+        })
+      );
+      directoryEntries.sort((a, b) => {
+        if (a.type === "directory" && b.type !== "directory") return -1;
+        if (a.type !== "directory" && b.type === "directory") return 1;
+        return a.name.localeCompare(b.name);
+      });
+      return { success: true, entries: directoryEntries };
+    } catch (error) {
+      logger.logger.debug("Failed to list directory:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
+    }
+  });
+  rpcHandlerManager.registerHandler("getDirectoryTree", async (data) => {
+    logger.logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    async function buildTree(path$1, name, currentDepth) {
+      try {
+        const stats = await fs.stat(path$1);
+        const node = {
+          name,
+          path: path$1,
+          type: stats.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.getTime()
+        };
+        if (stats.isDirectory() && currentDepth < data.maxDepth) {
+          const entries = await fs.readdir(path$1, { withFileTypes: true });
+          const children = [];
+          await Promise.all(
+            entries.map(async (entry) => {
+              if (entry.isSymbolicLink()) {
+                logger.logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
+                return;
+              }
+              const childPath = path.join(path$1, entry.name);
+              const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
+              if (childNode) {
+                children.push(childNode);
+              }
+            })
+          );
+          children.sort((a, b) => {
+            if (a.type === "directory" && b.type !== "directory") return -1;
+            if (a.type !== "directory" && b.type === "directory") return 1;
+            return a.name.localeCompare(b.name);
+          });
+          node.children = children;
+        }
+        return node;
+      } catch (error) {
+        logger.logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
+        return null;
+      }
+    }
+    try {
+      if (data.maxDepth < 0) {
+        return { success: false, error: "maxDepth must be non-negative" };
+      }
+      const rootPath = validation.resolvedPath;
+      const baseName = rootPath === "/" ? "/" : rootPath.split("/").pop() || rootPath;
+      const tree = await buildTree(rootPath, baseName, 0);
+      if (!tree) {
+        return { success: false, error: "Failed to access the specified path" };
+      }
+      return { success: true, tree };
+    } catch (error) {
+      logger.logger.debug("Failed to get directory tree:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
+    }
+  });
+  rpcHandlerManager.registerHandler("ripgrep", async (data) => {
+    logger.logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
+    if (data.cwd) {
+      const validation = validatePath(data.cwd, workingDirectory);
+      if (!validation.valid) {
+        return { success: false, error: validation.error };
+      }
+      data.cwd = validation.resolvedPath;
+    }
+    try {
+      const result = await run$1(data.args, { cwd: data.cwd });
+      return {
+        success: true,
+        exitCode: result.exitCode,
+        stdout: result.stdout.toString(),
+        stderr: result.stderr.toString()
+      };
+    } catch (error) {
+      logger.logger.debug("Failed to run ripgrep:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to run ripgrep"
+      };
+    }
+  });
+  rpcHandlerManager.registerHandler("difftastic", async (data) => {
+    logger.logger.debug("Difftastic request with args:", data.args, "cwd:", data.cwd);
+    if (data.cwd) {
+      const validation = validatePath(data.cwd, workingDirectory);
+      if (!validation.valid) {
+        return { success: false, error: validation.error };
+      }
+      data.cwd = validation.resolvedPath;
+    }
+    try {
+      const result = await run(data.args, { cwd: data.cwd });
+      return {
+        success: true,
+        exitCode: result.exitCode,
+        stdout: result.stdout.toString(),
+        stderr: result.stderr.toString()
+      };
+    } catch (error) {
+      logger.logger.debug("Failed to run difftastic:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to run difftastic"
+      };
+    }
+  });
+}
+
+exports.registerCommonHandlers = registerCommonHandlers;