@sarkar-ai/deskmate 0.2.0

package/dist/gateway/gateway.js

@@ -0,0 +1,435 @@
+"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.Gateway = void 0;
+const logger_1 = require("../core/logger");
+const executor_1 = require("../core/executor");
+const approval_1 = require("../core/approval");
+const agent_1 = require("../core/agent");
+const platform_1 = require("../core/platform");
+const security_1 = require("./security");
+const session_1 = require("./session");
+const log = (0, logger_1.createLogger)("Gateway");
+const SCREENSHOT_DIR = process.env.TMPDIR
+    ? `${process.env.TMPDIR}deskmate-screenshots`
+    : "/tmp/deskmate-screenshots";
+class Gateway {
+    clients = new Map();
+    security;
+    sessions;
+    executor;
+    agentProvider;
+    config;
+    systemPrompt;
+    constructor(config) {
+        this.config = config;
+        this.security = new security_1.SecurityManager(config.allowedUsers);
+        this.sessions = new session_1.SessionManager({
+            storagePath: config.storagePath,
+        });
+        this.executor = new executor_1.Executor(config.workingDir);
+        this.agentProvider = (0, agent_1.createAgentProvider)();
+        this.systemPrompt =
+            config.systemPrompt ||
+                `You are a local machine assistant named ${config.botName}. Users will ask you to perform tasks on their computer.
+
+You have access to tools to execute commands, read/write files, and explore the filesystem. Use them to help users accomplish their tasks.
+
+SCREENSHOT CAPABILITY:
+When the user asks to see the screen, take a screenshot, or wants visual feedback, use this command:
+  ${(0, platform_1.getScreenshotHint)(SCREENSHOT_DIR)}
+The screenshot will automatically be sent to the user after your response.
+
+IMPORTANT RULES:
+- Be concise in your responses
+- Use the available tools to accomplish tasks
+- For dangerous operations, explain what you're about to do before doing it
+- Never use sudo unless explicitly asked
+- Keep responses under 4000 characters
+- When asked for screenshots, always use the screenshot command above`;
+    }
+    registerClient(client) {
+        if (this.clients.has(client.clientType)) {
+            throw new Error(`Client type "${client.clientType}" is already registered`);
+        }
+        this.clients.set(client.clientType, client);
+        log.info("Client registered", { clientType: client.clientType });
+    }
+    async start() {
+        if (this.clients.size === 0) {
+            throw new Error("No clients registered. Register at least one MessagingClient before starting.");
+        }
+        // Verify agent provider
+        log.info("Using agent provider", {
+            name: this.agentProvider.name,
+            version: this.agentProvider.version,
+        });
+        const available = await this.agentProvider.isAvailable();
+        if (!available) {
+            log.warn("Agent provider may not be fully available", { provider: this.agentProvider.name });
+        }
+        // Register approval notifier that broadcasts to clients with recent activity
+        approval_1.approvalManager.addNotifier(async (action) => {
+            await this.broadcastApproval(action);
+        });
+        // Start all clients
+        for (const client of this.clients.values()) {
+            await client.start(this);
+            log.info("Client started", { clientType: client.clientType });
+        }
+        log.info("Gateway started", { clients: Array.from(this.clients.keys()) });
+    }
+    async stop() {
+        for (const client of this.clients.values()) {
+            await client.stop();
+        }
+        this.sessions.stop();
+        if (this.agentProvider.cleanup) {
+            await this.agentProvider.cleanup();
+        }
+        log.info("Gateway stopped");
+    }
+    // ── MessageHandler implementation ───────────────────────────────────
+    async handleMessage(msg) {
+        // Auth check
+        if (!this.security.isAuthorized(msg.clientType, msg.userId)) {
+            log.debug("Unauthorized message dropped", {
+                clientType: msg.clientType,
+                userId: msg.userId,
+            });
+            return;
+        }
+        if (msg.command) {
+            await this.handleCommand(msg);
+        }
+        else {
+            await this.handleAgentQuery(msg);
+        }
+    }
+    async handleApproval(response, channelId) {
+        const { actionId, approved } = response;
+        let success;
+        if (approved) {
+            success = approval_1.approvalManager.approve(actionId);
+        }
+        else {
+            success = approval_1.approvalManager.reject(actionId);
+        }
+        // Update approval UI on all clients that have the channel
+        for (const client of this.clients.values()) {
+            try {
+                await client.updateApprovalStatus(channelId, actionId, approved);
+            }
+            catch {
+                // Client may not own this channel — ignore
+            }
+        }
+        if (!success) {
+            log.warn("Approval action not found", { actionId });
+        }
+    }
+    // ── Commands ────────────────────────────────────────────────────────
+    async handleCommand(msg) {
+        const client = this.clients.get(msg.clientType);
+        if (!client)
+            return;
+        switch (msg.command) {
+            case "start":
+                await client.sendMessage({
+                    channelId: msg.channelId,
+                    text: `*${this.config.botName} Ready*\n\n` +
+                        "Send me any task and I'll execute it on your local machine.\n\n" +
+                        "I remember our conversation, so you can ask follow-up questions!\n\n" +
+                        "*Examples:*\n" +
+                        "- `list all docker containers`\n" +
+                        "- `what's using port 3000?`\n" +
+                        "- `show disk usage`\n" +
+                        "- `take a screenshot`\n\n" +
+                        "*Commands:*\n" +
+                        "- /screenshot - Take a screenshot\n" +
+                        "- /status - System info\n" +
+                        "- /reset - Clear memory & start fresh",
+                    parseMode: "markdown",
+                });
+                break;
+            case "screenshot":
+                await this.handleScreenshotCommand(msg, client);
+                break;
+            case "status":
+                await this.handleStatusCommand(msg, client);
+                break;
+            case "reset":
+                await this.handleResetCommand(msg, client);
+                break;
+            default:
+                log.debug("Unknown command", { command: msg.command });
+        }
+    }
+    async handleScreenshotCommand(msg, client) {
+        await client.sendMessage({ channelId: msg.channelId, text: "Taking screenshot..." });
+        try {
+            const filepath = await this.executor.takeScreenshot();
+            if (filepath) {
+                await client.sendMessage({
+                    channelId: msg.channelId,
+                    image: filepath,
+                    imageCaption: "Screenshot",
+                });
+                // Clean up
+                const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+                await fs.unlink(filepath).catch(() => { });
+            }
+            else {
+                await client.sendMessage({
+                    channelId: msg.channelId,
+                    text: "Screenshot failed.",
+                });
+            }
+        }
+        catch (error) {
+            log.error("Screenshot command failed", { error: error.message });
+            await client.sendMessage({
+                channelId: msg.channelId,
+                text: `Screenshot failed: ${error.message}`,
+            });
+        }
+    }
+    async handleStatusCommand(msg, client) {
+        const pending = approval_1.approvalManager.getPendingActions();
+        const info = await this.executor.getSystemInfo();
+        const hasSession = this.sessions.has(msg.clientType, msg.channelId);
+        await client.sendMessage({
+            channelId: msg.channelId,
+            text: `*System Status*\n\n` +
+                `- Host: ${info.hostname || "unknown"}\n` +
+                `- Platform: ${info.platform}\n` +
+                `- Agent: ${this.agentProvider.name} v${this.agentProvider.version}\n` +
+                `- Pending approvals: ${pending.length}\n` +
+                `- Working dir: \`${this.executor.getWorkingDir()}\`\n` +
+                `- Session active: ${hasSession ? "Yes" : "No"}`,
+            parseMode: "markdown",
+        });
+    }
+    async handleResetCommand(msg, client) {
+        const had = this.sessions.delete(msg.clientType, msg.channelId);
+        log.info("Session reset", { clientType: msg.clientType, channelId: msg.channelId, had });
+        await client.sendMessage({
+            channelId: msg.channelId,
+            text: had
+                ? "Session cleared! Starting fresh conversation."
+                : "No active session to clear.",
+        });
+    }
+    // ── Agent query loop ────────────────────────────────────────────────
+    async handleAgentQuery(msg) {
+        const client = this.clients.get(msg.clientType);
+        if (!client)
+            return;
+        // Send "Thinking..." placeholder
+        const thinkingId = await client.sendMessage({
+            channelId: msg.channelId,
+            text: "Thinking...",
+        });
+        const executionStartTime = new Date();
+        const existingSessionId = this.sessions.get(msg.clientType, msg.channelId);
+        log.info("Received message", {
+            clientType: msg.clientType,
+            userId: msg.userId,
+            channelId: msg.channelId,
+            hasSession: !!existingSessionId,
+            message: msg.text.slice(0, 100),
+        });
+        try {
+            let result = "";
+            let lastUpdate = Date.now();
+            let newSessionId;
+            for await (const event of this.agentProvider.queryStream(msg.text, {
+                systemPrompt: this.systemPrompt,
+                workingDir: this.config.workingDir,
+                sessionId: existingSessionId,
+                maxTurns: this.config.maxTurns ?? 10,
+            })) {
+                switch (event.type) {
+                    case "text":
+                        if (event.text)
+                            result = event.text;
+                        break;
+                    case "tool_use":
+                        log.debug("Tool use", { tool: event.toolName });
+                        break;
+                    case "done":
+                        if (event.response) {
+                            result = event.response.text;
+                            newSessionId = event.response.sessionId;
+                        }
+                        break;
+                    case "error":
+                        throw new Error(event.error || "Unknown agent error");
+                }
+                // Periodic progress update
+                if (thinkingId && Date.now() - lastUpdate > 3000) {
+                    try {
+                        await client.sendMessage({
+                            channelId: msg.channelId,
+                            text: "Working...",
+                            editMessageId: thinkingId,
+                        });
+                        lastUpdate = Date.now();
+                    }
+                    catch {
+                        // Ignore edit errors
+                    }
+                }
+            }
+            // Store session
+            if (newSessionId) {
+                this.sessions.set(msg.clientType, msg.channelId, newSessionId);
+                log.info("Session stored", { channelId: msg.channelId, sessionId: newSessionId });
+            }
+            // Send final result
+            const finalMessage = result || "Task completed (no output)";
+            const truncated = finalMessage.slice(0, 4000);
+            log.info("Agent completed", { resultLength: finalMessage.length, hasSession: !!newSessionId });
+            // Try markdown first, fall back to plain
+            try {
+                await client.sendMessage({
+                    channelId: msg.channelId,
+                    text: truncated,
+                    editMessageId: thinkingId,
+                    parseMode: "markdown",
+                });
+            }
+            catch {
+                await client.sendMessage({
+                    channelId: msg.channelId,
+                    text: truncated,
+                    editMessageId: thinkingId,
+                    parseMode: "plain",
+                });
+            }
+            // Send any screenshots taken during execution
+            await this.sendScreenshots(client, msg.channelId, executionStartTime);
+        }
+        catch (error) {
+            log.error("Agent error", { error: error.message });
+            if (error.message?.includes("session")) {
+                this.sessions.delete(msg.clientType, msg.channelId);
+                log.warn("Cleared invalid session", { channelId: msg.channelId });
+            }
+            await client.sendMessage({
+                channelId: msg.channelId,
+                text: `Error: ${error.message}`,
+                editMessageId: thinkingId,
+            });
+        }
+    }
+    // ── Screenshots ─────────────────────────────────────────────────────
+    async sendScreenshots(client, channelId, since) {
+        try {
+            const screenshots = await this.executor.getRecentScreenshots(since);
+            const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+            for (const filepath of screenshots) {
+                await client.sendMessage({
+                    channelId,
+                    image: filepath,
+                    imageCaption: "Screenshot",
+                });
+                await fs.unlink(filepath).catch(() => { });
+            }
+            if (screenshots.length > 0) {
+                log.info("Screenshots sent", { count: screenshots.length });
+            }
+        }
+        catch (error) {
+            log.error("Failed to send screenshots", { error: error.message });
+        }
+    }
+    // ── Approval broadcasting ───────────────────────────────────────────
+    async broadcastApproval(action) {
+        const timeLeft = Math.ceil((action.expiresAt.getTime() - Date.now()) / 1000);
+        let details = "";
+        switch (action.type) {
+            case "command":
+                details = `Command: \`${action.details.command}\``;
+                break;
+            case "write_file":
+                details = `Path: \`${action.details.path}\`\nPreview: ${(action.details.contentPreview || "").slice(0, 100)}...`;
+                break;
+            case "folder_access":
+                details = `Folder: \`${action.details.baseFolder}\`\nFile: \`${action.details.path}\``;
+                break;
+            case "read_file":
+                details = `Path: \`${action.details.path}\``;
+                break;
+            default:
+                details = JSON.stringify(action.details, null, 2);
+        }
+        // Send to all clients that have recently-active channels
+        const recentChannels = this.sessions.getRecentChannels(30 * 60 * 1000);
+        // Group by clientType
+        const channelsByClient = new Map();
+        for (const { clientType, channelId } of recentChannels) {
+            if (!channelsByClient.has(clientType)) {
+                channelsByClient.set(clientType, []);
+            }
+            channelsByClient.get(clientType).push(channelId);
+        }
+        for (const [clientType, channelIds] of channelsByClient) {
+            const client = this.clients.get(clientType);
+            if (!client)
+                continue;
+            for (const channelId of channelIds) {
+                try {
+                    await client.sendApprovalPrompt({
+                        channelId,
+                        actionId: action.id,
+                        type: action.type,
+                        description: action.description,
+                        details,
+                        expiresInSeconds: timeLeft,
+                    });
+                }
+                catch (error) {
+                    log.error("Failed to send approval prompt", {
+                        clientType,
+                        channelId,
+                        error: error.message,
+                    });
+                }
+            }
+        }
+    }
+}
+exports.Gateway = Gateway;

package/dist/gateway/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = exports.SecurityManager = exports.Gateway = void 0;
+var gateway_1 = require("./gateway");
+Object.defineProperty(exports, "Gateway", { enumerable: true, get: function () { return gateway_1.Gateway; } });
+var security_1 = require("./security");
+Object.defineProperty(exports, "SecurityManager", { enumerable: true, get: function () { return security_1.SecurityManager; } });
+var session_1 = require("./session");
+Object.defineProperty(exports, "SessionManager", { enumerable: true, get: function () { return session_1.SessionManager; } });

package/dist/gateway/security.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityManager = void 0;
+const logger_1 = require("../core/logger");
+const log = (0, logger_1.createLogger)("SecurityManager");
+class SecurityManager {
+    /** Map<clientType, Set<platformUserId>> — wildcard "*" matches any user */
+    allowList = new Map();
+    constructor(allowedUsers) {
+        for (const u of allowedUsers) {
+            this.addUser(u);
+        }
+        log.info("SecurityManager initialized", { userCount: allowedUsers.length });
+    }
+    addUser(identity) {
+        const { clientType, platformUserId } = identity;
+        if (!this.allowList.has(clientType)) {
+            this.allowList.set(clientType, new Set());
+        }
+        this.allowList.get(clientType).add(platformUserId);
+        log.debug("User added to allowlist", { clientType, platformUserId });
+    }
+    isAuthorized(clientType, platformUserId) {
+        // Check wildcard first
+        const wildcardSet = this.allowList.get("*");
+        if (wildcardSet?.has("*") || wildcardSet?.has(platformUserId)) {
+            return true;
+        }
+        const clientSet = this.allowList.get(clientType);
+        if (!clientSet)
+            return false;
+        return clientSet.has("*") || clientSet.has(platformUserId);
+    }
+}
+exports.SecurityManager = SecurityManager;

package/dist/gateway/session.js

@@ -0,0 +1,195 @@
+"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.SessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../core/logger");
+const log = (0, logger_1.createLogger)("SessionManager");
+class SessionManager {
+    /** Composite key: `clientType:channelId` -> session */
+    sessions = new Map();
+    idleTimeoutMs;
+    pruneInterval = null;
+    storagePath;
+    saveTimer = null;
+    static DEBOUNCE_MS = 500;
+    constructor(options) {
+        const idleTimeoutMs = options?.idleTimeoutMs ?? 30 * 60 * 1000;
+        this.idleTimeoutMs = idleTimeoutMs;
+        this.storagePath = options?.storagePath ?? null;
+        if (this.storagePath) {
+            this.loadFromDisk();
+        }
+        this.pruneInterval = setInterval(() => this.pruneIdle(), 60_000);
+        log.info("SessionManager initialized", { idleTimeoutMs, storagePath: this.storagePath });
+    }
+    key(clientType, channelId) {
+        return `${clientType}:${channelId}`;
+    }
+    get(clientType, channelId) {
+        const entry = this.sessions.get(this.key(clientType, channelId));
+        if (entry) {
+            entry.lastActivity = new Date();
+            this.scheduleSave();
+            return entry.agentSessionId;
+        }
+        return undefined;
+    }
+    set(clientType, channelId, agentSessionId) {
+        const k = this.key(clientType, channelId);
+        this.sessions.set(k, {
+            agentSessionId,
+            createdAt: new Date(),
+            lastActivity: new Date(),
+        });
+        log.debug("Session stored", { key: k, agentSessionId });
+        this.scheduleSave();
+    }
+    delete(clientType, channelId) {
+        const k = this.key(clientType, channelId);
+        const had = this.sessions.has(k);
+        this.sessions.delete(k);
+        if (had) {
+            log.debug("Session deleted", { key: k });
+            this.scheduleSave();
+        }
+        return had;
+    }
+    has(clientType, channelId) {
+        return this.sessions.has(this.key(clientType, channelId));
+    }
+    /** Remove sessions that have been idle longer than idleTimeoutMs */
+    pruneIdle() {
+        const now = Date.now();
+        let pruned = 0;
+        for (const [k, entry] of this.sessions) {
+            if (now - entry.lastActivity.getTime() > this.idleTimeoutMs) {
+                this.sessions.delete(k);
+                pruned++;
+            }
+        }
+        if (pruned > 0) {
+            log.info("Pruned idle sessions", { pruned, remaining: this.sessions.size });
+            this.scheduleSave();
+        }
+    }
+    /** Get all channel IDs with recent activity (within the last N ms) */
+    getRecentChannels(withinMs) {
+        const cutoff = Date.now() - withinMs;
+        const result = [];
+        for (const [k, entry] of this.sessions) {
+            if (entry.lastActivity.getTime() >= cutoff) {
+                const [clientType, ...rest] = k.split(":");
+                result.push({ clientType, channelId: rest.join(":") });
+            }
+        }
+        return result;
+    }
+    stop() {
+        if (this.pruneInterval) {
+            clearInterval(this.pruneInterval);
+            this.pruneInterval = null;
+        }
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        // Flush any pending save synchronously on stop
+        if (this.storagePath) {
+            this.saveToDiskSync();
+        }
+    }
+    // ── Persistence ──────────────────────────────────────────────
+    loadFromDisk() {
+        if (!this.storagePath)
+            return;
+        try {
+            const raw = fs.readFileSync(this.storagePath, "utf-8");
+            const data = JSON.parse(raw);
+            for (const [key, entry] of Object.entries(data)) {
+                this.sessions.set(key, {
+                    agentSessionId: entry.agentSessionId,
+                    createdAt: new Date(entry.createdAt),
+                    lastActivity: new Date(entry.lastActivity),
+                });
+            }
+            log.info("Loaded sessions from disk", { count: this.sessions.size, path: this.storagePath });
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                log.info("No existing session file, starting fresh", { path: this.storagePath });
+            }
+            else {
+                log.warn("Failed to load sessions from disk, starting fresh", { error: err.message, path: this.storagePath });
+            }
+        }
+    }
+    serialize() {
+        const data = {};
+        for (const [key, entry] of this.sessions) {
+            data[key] = {
+                agentSessionId: entry.agentSessionId,
+                createdAt: entry.createdAt.toISOString(),
+                lastActivity: entry.lastActivity.toISOString(),
+            };
+        }
+        return data;
+    }
+    saveToDiskSync() {
+        if (!this.storagePath)
+            return;
+        try {
+            const dir = path.dirname(this.storagePath);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(this.storagePath, JSON.stringify(this.serialize(), null, 2));
+        }
+        catch (err) {
+            log.error("Failed to save sessions to disk", { error: err.message, path: this.storagePath });
+        }
+    }
+    scheduleSave() {
+        if (!this.storagePath)
+            return;
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+        }
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = null;
+            this.saveToDiskSync();
+        }, SessionManager.DEBOUNCE_MS);
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/gateway/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Gateway Types
+ *
+ * Shared interfaces for the multi-client gateway architecture.
+ * Platform adapters implement MessagingClient; the Gateway implements MessageHandler.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });