@sarkar-ai/deskmate 0.2.0

package/dist/core/executor.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const logger_1 = require("./logger");
+const approval_1 = require("./approval");
+const platform_1 = require("./platform");
+const log = (0, logger_1.createLogger)("Executor");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// Screenshot directory
+const SCREENSHOT_DIR = path.join(os.tmpdir(), "deskmate-screenshots");
+class Executor {
+    workingDir;
+    constructor(workingDir) {
+        this.workingDir = workingDir || process.env.WORKING_DIR || process.env.HOME || "/";
+    }
+    async executeCommand(command, cwd) {
+        const workingDir = cwd || this.workingDir;
+        log.info("Executing command", { command, workingDir });
+        log.debug("Command details", { shell: process.platform === "win32" ? "powershell.exe" : "/bin/zsh" });
+        try {
+            const startTime = Date.now();
+            const { stdout, stderr } = await execAsync(command, {
+                cwd: workingDir,
+                timeout: 120000, // 2 minute timeout
+                maxBuffer: 1024 * 1024 * 10, // 10MB buffer
+                shell: process.platform === "win32" ? "powershell.exe" : "/bin/zsh",
+                env: { ...process.env, PATH: process.env.PATH },
+            });
+            const duration = Date.now() - startTime;
+            const output = (stdout || stderr).trim();
+            log.info("Command completed successfully", { command, exitCode: 0, durationMs: duration });
+            log.debug("Command output", { output: output.slice(0, 500), outputLength: output.length });
+            return {
+                success: true,
+                output: output || "(command completed with no output)",
+                exitCode: 0,
+            };
+        }
+        catch (error) {
+            log.error("Command failed", {
+                command,
+                exitCode: error.code ?? 1,
+                error: error.message,
+            });
+            log.debug("Command error details", { stderr: error.stderr, stdout: error.stdout });
+            return {
+                success: false,
+                output: error.stderr || error.stdout || error.message,
+                exitCode: error.code ?? 1,
+            };
+        }
+    }
+    async readFile(filePath) {
+        const resolvedPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(this.workingDir, filePath);
+        log.debug("Reading file", { filePath, resolvedPath });
+        // Check if folder access approval is needed
+        const approved = await approval_1.approvalManager.requestFolderAccess(resolvedPath);
+        if (!approved) {
+            throw new Error(`Access to ${resolvedPath} was not approved`);
+        }
+        const content = await fs.readFile(resolvedPath, "utf-8");
+        log.info("File read successfully", { filePath: resolvedPath, size: content.length });
+        return content;
+    }
+    async writeFile(filePath, content) {
+        const resolvedPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(this.workingDir, filePath);
+        log.debug("Writing file", { filePath, resolvedPath, contentLength: content.length });
+        // Check if folder access approval is needed
+        const approved = await approval_1.approvalManager.requestFolderAccess(resolvedPath);
+        if (!approved) {
+            throw new Error(`Access to ${resolvedPath} was not approved`);
+        }
+        await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+        await fs.writeFile(resolvedPath, content, "utf-8");
+        log.info("File written successfully", { filePath: resolvedPath, size: content.length });
+    }
+    async listDirectory(dirPath) {
+        const resolvedPath = dirPath
+            ? path.isAbsolute(dirPath)
+                ? dirPath
+                : path.join(this.workingDir, dirPath)
+            : this.workingDir;
+        log.debug("Listing directory", { dirPath, resolvedPath });
+        // Check if folder access approval is needed
+        const approved = await approval_1.approvalManager.requestFolderAccess(resolvedPath);
+        if (!approved) {
+            throw new Error(`Access to ${resolvedPath} was not approved`);
+        }
+        const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            const fullPath = path.join(resolvedPath, entry.name);
+            try {
+                const stats = await fs.stat(fullPath);
+                files.push({
+                    name: entry.name,
+                    path: fullPath,
+                    isDirectory: entry.isDirectory(),
+                    size: stats.size,
+                    modified: stats.mtime,
+                });
+            }
+            catch {
+                // Skip files we can't stat
+            }
+        }
+        log.info("Directory listed", { path: resolvedPath, itemCount: files.length });
+        return files;
+    }
+    async getSystemInfo() {
+        const info = {
+            platform: process.platform,
+            arch: process.arch,
+            nodeVersion: process.version,
+            workingDir: this.workingDir,
+            homeDir: process.env.HOME || "",
+            user: process.env.USER || "",
+        };
+        // Get additional system info
+        try {
+            const { stdout: hostname } = await execAsync("hostname");
+            info.hostname = hostname.trim();
+        }
+        catch { }
+        try {
+            const { stdout: uptime } = await execAsync("uptime");
+            info.uptime = uptime.trim();
+        }
+        catch { }
+        return info;
+    }
+    getWorkingDir() {
+        return this.workingDir;
+    }
+    setWorkingDir(dir) {
+        this.workingDir = dir;
+    }
+    async takeScreenshot() {
+        try {
+            // Ensure screenshot directory exists
+            await fs.mkdir(SCREENSHOT_DIR, { recursive: true });
+            const filename = `screenshot-${Date.now()}.png`;
+            const filepath = path.join(SCREENSHOT_DIR, filename);
+            log.info("Taking screenshot", { filepath });
+            await execAsync((0, platform_1.getScreenshotCommand)(filepath), {
+                timeout: 10000,
+            });
+            // Verify file was created
+            await fs.access(filepath);
+            log.info("Screenshot saved", { filepath });
+            return filepath;
+        }
+        catch (error) {
+            log.error("Screenshot failed", { error: error.message });
+            return null;
+        }
+    }
+    async getRecentScreenshots(since) {
+        try {
+            await fs.mkdir(SCREENSHOT_DIR, { recursive: true });
+            const files = await fs.readdir(SCREENSHOT_DIR);
+            const screenshots = [];
+            for (const file of files) {
+                if (!file.endsWith(".png"))
+                    continue;
+                const filepath = path.join(SCREENSHOT_DIR, file);
+                const stats = await fs.stat(filepath);
+                if (stats.mtime >= since) {
+                    screenshots.push(filepath);
+                }
+            }
+            return screenshots.sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    async cleanupScreenshots() {
+        try {
+            const files = await fs.readdir(SCREENSHOT_DIR);
+            for (const file of files) {
+                if (file.endsWith(".png")) {
+                    await fs.unlink(path.join(SCREENSHOT_DIR, file)).catch(() => { });
+                }
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    getScreenshotDir() {
+        return SCREENSHOT_DIR;
+    }
+}
+exports.Executor = Executor;

package/dist/core/logger.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStderrLogger = exports.createLogger = exports.logger = void 0;
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4,
+};
+class Logger {
+    level;
+    context;
+    useStderr;
+    constructor(options) {
+        if (typeof options === "string") {
+            this.context = options;
+            this.useStderr = false;
+        }
+        else {
+            this.context = options?.context;
+            this.useStderr = options?.useStderr ?? false;
+        }
+        this.level = process.env.LOG_LEVEL?.toLowerCase() || "info";
+    }
+    shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+    }
+    formatMessage(level, message, data) {
+        const timestamp = new Date().toISOString();
+        const ctx = this.context ? `[${this.context}]` : "";
+        const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+        return `${timestamp} ${level.toUpperCase().padEnd(5)} ${ctx} ${message}${dataStr}`;
+    }
+    output(method, message) {
+        if (this.useStderr) {
+            console.error(message);
+        }
+        else {
+            console[method](message);
+        }
+    }
+    debug(message, data) {
+        if (this.shouldLog("debug")) {
+            this.output("log", this.formatMessage("debug", message, data));
+        }
+    }
+    info(message, data) {
+        if (this.shouldLog("info")) {
+            this.output("log", this.formatMessage("info", message, data));
+        }
+    }
+    warn(message, data) {
+        if (this.shouldLog("warn")) {
+            this.output("warn", this.formatMessage("warn", message, data));
+        }
+    }
+    error(message, data) {
+        if (this.shouldLog("error")) {
+            this.output("error", this.formatMessage("error", message, data));
+        }
+    }
+    child(context) {
+        const childLogger = new Logger({
+            context: this.context ? `${this.context}:${context}` : context,
+            useStderr: this.useStderr,
+        });
+        childLogger.level = this.level;
+        return childLogger;
+    }
+}
+exports.logger = new Logger();
+const createLogger = (context) => new Logger(context);
+exports.createLogger = createLogger;
+const createStderrLogger = (context) => new Logger({ context, useStderr: true });
+exports.createStderrLogger = createStderrLogger;

package/dist/core/platform.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_WINDOWS = exports.IS_LINUX = exports.IS_MACOS = void 0;
+exports.getScreenshotCommand = getScreenshotCommand;
+exports.getProtectedFolderPatterns = getProtectedFolderPatterns;
+exports.extractBaseFolder = extractBaseFolder;
+exports.getScreenshotHint = getScreenshotHint;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.IS_MACOS = process.platform === "darwin";
+exports.IS_LINUX = process.platform === "linux";
+exports.IS_WINDOWS = process.platform === "win32";
+/**
+ * Returns the platform-appropriate command to take a screenshot.
+ */
+function getScreenshotCommand(filepath) {
+    if (exports.IS_MACOS)
+        return `screencapture -x "${filepath}"`;
+    if (exports.IS_LINUX)
+        return `import -window root "${filepath}"`;
+    if (exports.IS_WINDOWS)
+        return `powershell -c "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::PrimaryScreen | ForEach-Object { $bmp = New-Object System.Drawing.Bitmap($_.Bounds.Width, $_.Bounds.Height); $g = [System.Drawing.Graphics]::FromImage($bmp); $g.CopyFromScreen($_.Bounds.Location, [System.Drawing.Point]::Empty, $_.Bounds.Size); $bmp.Save('${filepath.replace(/'/g, "''")}') }"`;
+    return `echo "Screenshots not supported on ${process.platform}"`;
+}
+/**
+ * Returns regex patterns matching protected user folders for the current OS.
+ */
+function getProtectedFolderPatterns() {
+    const home = os.homedir().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (exports.IS_MACOS) {
+        return [
+            new RegExp(`^${home}/Desktop`),
+            new RegExp(`^${home}/Documents`),
+            new RegExp(`^${home}/Downloads`),
+            new RegExp(`^${home}/Pictures`),
+            new RegExp(`^${home}/Movies`),
+            new RegExp(`^${home}/Music`),
+            new RegExp(`^${home}/Library/Mobile Documents`),
+        ];
+    }
+    if (exports.IS_LINUX) {
+        return [
+            new RegExp(`^${home}/Desktop`),
+            new RegExp(`^${home}/Documents`),
+            new RegExp(`^${home}/Downloads`),
+            new RegExp(`^${home}/Pictures`),
+            new RegExp(`^${home}/Videos`),
+            new RegExp(`^${home}/Music`),
+        ];
+    }
+    // Windows
+    const winHome = home.replace(/\\/g, "[\\\\/]");
+    return [
+        new RegExp(`^${winHome}[\\\\/]Desktop`, "i"),
+        new RegExp(`^${winHome}[\\\\/]Documents`, "i"),
+        new RegExp(`^${winHome}[\\\\/]Downloads`, "i"),
+        new RegExp(`^${winHome}[\\\\/]Pictures`, "i"),
+        new RegExp(`^${winHome}[\\\\/]Videos`, "i"),
+        new RegExp(`^${winHome}[\\\\/]Music`, "i"),
+    ];
+}
+/**
+ * Extracts the base protected folder from a file path (e.g. /home/user/Desktop).
+ * Returns null if the path is not inside a protected folder.
+ */
+function extractBaseFolder(filePath) {
+    const home = os.homedir();
+    const folders = exports.IS_MACOS
+        ? [
+            "Desktop",
+            "Documents",
+            "Downloads",
+            "Pictures",
+            "Movies",
+            "Music",
+            "Library/Mobile Documents",
+        ]
+        : ["Desktop", "Documents", "Downloads", "Pictures", "Videos", "Music"];
+    for (const folder of folders) {
+        const prefix = path.join(home, folder);
+        if (filePath.startsWith(prefix))
+            return prefix;
+    }
+    return null;
+}
+/**
+ * Returns a shell snippet for the system prompt that shows how to take a screenshot.
+ */
+function getScreenshotHint(screenshotDir) {
+    if (exports.IS_MACOS) {
+        return `mkdir -p ${screenshotDir} && screencapture -x ${screenshotDir}/screenshot-$(date +%s).png && echo "Screenshot saved"`;
+    }
+    if (exports.IS_LINUX) {
+        return `mkdir -p ${screenshotDir} && import -window root ${screenshotDir}/screenshot-$(date +%s).png && echo "Screenshot saved"`;
+    }
+    return `echo "Use the /screenshot command instead"`;
+}