@sarkar-ai/deskmate 0.2.0

package/dist/clients/telegram.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramClient = void 0;
+const grammy_1 = require("grammy");
+const logger_1 = require("../core/logger");
+const log = (0, logger_1.createLogger)("TelegramClient");
+class TelegramClient {
+    clientType = "telegram";
+    bot;
+    handler = null;
+    constructor(token) {
+        this.bot = new grammy_1.Bot(token);
+    }
+    async start(handler) {
+        this.handler = handler;
+        // Map commands to IncomingMessage
+        this.bot.command("start", (ctx) => this.dispatch(ctx, "start"));
+        this.bot.command("screenshot", (ctx) => this.dispatch(ctx, "screenshot"));
+        this.bot.command("status", (ctx) => this.dispatch(ctx, "status"));
+        this.bot.command("reset", (ctx) => this.dispatch(ctx, "reset"));
+        // Text messages
+        this.bot.on("message:text", async (ctx) => {
+            if (!this.handler)
+                return;
+            await this.handler.handleMessage({
+                platformMessageId: String(ctx.message.message_id),
+                channelId: String(ctx.chat.id),
+                userId: String(ctx.from?.id ?? ""),
+                clientType: this.clientType,
+                text: ctx.message.text,
+            });
+        });
+        // Approval callbacks
+        this.bot.callbackQuery(/^approve:(.+)$/, async (ctx) => {
+            if (!this.handler)
+                return;
+            const actionId = ctx.match[1];
+            await this.handler.handleApproval({ actionId, approved: true }, String(ctx.chat?.id ?? ""));
+            await ctx.answerCallbackQuery({ text: "Approved!" });
+        });
+        this.bot.callbackQuery(/^reject:(.+)$/, async (ctx) => {
+            if (!this.handler)
+                return;
+            const actionId = ctx.match[1];
+            await this.handler.handleApproval({ actionId, approved: false }, String(ctx.chat?.id ?? ""));
+            await ctx.answerCallbackQuery({ text: "Rejected" });
+        });
+        // Start polling
+        this.bot.start({
+            drop_pending_updates: true,
+            onStart: (info) => log.info("Telegram bot started", { username: info.username }),
+        });
+    }
+    async dispatch(ctx, command) {
+        if (!this.handler)
+            return;
+        await this.handler.handleMessage({
+            platformMessageId: String(ctx.message?.message_id ?? ""),
+            channelId: String(ctx.chat.id),
+            userId: String(ctx.from?.id ?? ""),
+            clientType: this.clientType,
+            text: ctx.message?.text ?? "",
+            command,
+        });
+    }
+    async sendMessage(message) {
+        const chatId = Number(message.channelId);
+        // Image message
+        if (message.image) {
+            const source = typeof message.image === "string"
+                ? new grammy_1.InputFile(message.image)
+                : new grammy_1.InputFile(message.image);
+            const sent = await this.bot.api.sendPhoto(chatId, source, {
+                caption: message.imageCaption,
+            });
+            return String(sent.message_id);
+        }
+        const text = message.text ?? "";
+        const truncated = text.slice(0, 4000);
+        // Edit existing message
+        if (message.editMessageId) {
+            const msgId = Number(message.editMessageId);
+            try {
+                if (message.parseMode === "markdown") {
+                    await this.bot.api.editMessageText(chatId, msgId, truncated, {
+                        parse_mode: "Markdown",
+                    });
+                }
+                else {
+                    await this.bot.api.editMessageText(chatId, msgId, truncated);
+                }
+            }
+            catch {
+                // If markdown parse fails, retry as plain
+                await this.bot.api.editMessageText(chatId, msgId, truncated);
+            }
+            return message.editMessageId;
+        }
+        // New message
+        const opts = {};
+        if (message.parseMode === "markdown") {
+            opts.parse_mode = "Markdown";
+        }
+        const sent = await this.bot.api.sendMessage(chatId, truncated, opts);
+        return String(sent.message_id);
+    }
+    async sendApprovalPrompt(prompt) {
+        const chatId = Number(prompt.channelId);
+        const keyboard = new grammy_1.InlineKeyboard()
+            .text("Approve", `approve:${prompt.actionId}`)
+            .text("Reject", `reject:${prompt.actionId}`);
+        let emoji = "";
+        switch (prompt.type) {
+            case "command":
+                emoji = "Command";
+                break;
+            case "write_file":
+                emoji = "Write File";
+                break;
+            case "folder_access":
+                emoji = "Folder Access";
+                break;
+            case "read_file":
+                emoji = "Read File";
+                break;
+            default:
+                emoji = "Action";
+        }
+        await this.bot.api.sendMessage(chatId, `*Approval Required — ${emoji}*\n\n` +
+            `Type: \`${prompt.type}\`\n` +
+            `${prompt.description}\n\n` +
+            `${prompt.details}\n\n` +
+            `Expires in ${prompt.expiresInSeconds}s`, { parse_mode: "Markdown", reply_markup: keyboard });
+    }
+    async updateApprovalStatus(channelId, _actionId, approved) {
+        // The callback query handler already answered; we don't need to
+        // edit anything extra here since Grammy's callbackQuery handler
+        // will have already been invoked. If we wanted to edit the original
+        // approval message we'd need to track message IDs per actionId.
+        // For now, the inline callback answer suffices.
+        log.debug("Approval status updated", { channelId, approved });
+    }
+    async stop() {
+        this.bot.stop();
+        log.info("Telegram bot stopped");
+    }
+}
+exports.TelegramClient = TelegramClient;

package/dist/core/agent/factory.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Agent Provider Factory
+ *
+ * Creates agent provider instances based on configuration.
+ * Ships with claude-code as the default provider.
+ * Users can register custom providers via registerProvider().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentProvider = createAgentProvider;
+exports.getDefaultProviderType = getDefaultProviderType;
+exports.getAvailableProviders = getAvailableProviders;
+exports.registerProvider = registerProvider;
+exports.isProviderAvailable = isProviderAvailable;
+const claude_code_1 = require("./providers/claude-code");
+const logger_1 = require("../logger");
+const log = (0, logger_1.createLogger)("AgentFactory");
+// Registry of available providers — extensible via registerProvider()
+const providerRegistry = new Map([
+    ["claude-code", claude_code_1.ClaudeCodeProvider],
+]);
+/**
+ * Create an agent provider based on configuration
+ */
+function createAgentProvider(config) {
+    const providerType = config?.type || getDefaultProviderType();
+    log.info("Creating agent provider", { type: providerType });
+    const ProviderClass = providerRegistry.get(providerType);
+    if (!ProviderClass) {
+        const available = Array.from(providerRegistry.keys()).join(", ");
+        throw new Error(`Unknown agent provider: ${providerType}. Available: ${available}`);
+    }
+    return new ProviderClass();
+}
+/**
+ * Get the default provider type from environment or fallback
+ */
+function getDefaultProviderType() {
+    const envProvider = process.env.AGENT_PROVIDER;
+    if (envProvider && providerRegistry.has(envProvider)) {
+        return envProvider;
+    }
+    return "claude-code";
+}
+/**
+ * Get list of available provider types
+ */
+function getAvailableProviders() {
+    return Array.from(providerRegistry.keys());
+}
+/**
+ * Register a custom agent provider.
+ *
+ * Example:
+ *   registerProvider("my-agent", MyAgentProvider);
+ *   // then set AGENT_PROVIDER=my-agent in .env
+ */
+function registerProvider(type, providerClass) {
+    log.info("Registering custom provider", { type });
+    providerRegistry.set(type, providerClass);
+}
+/**
+ * Check if a provider type is available
+ */
+function isProviderAvailable(type) {
+    return providerRegistry.has(type);
+}

package/dist/core/agent/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Agent Module
+ *
+ * Provides an abstraction layer for AI agent providers.
+ * Ships with claude-code as the default (and recommended) provider.
+ *
+ * Usage:
+ *   import { createAgentProvider } from "./core/agent";
+ *   const agent = createAgentProvider();
+ *   const response = await agent.query("Hello");
+ *
+ * To add a custom provider:
+ *   1. Implement the AgentProvider interface
+ *   2. Call registerProvider("my-agent", MyProvider)
+ *   3. Set AGENT_PROVIDER=my-agent in .env
+ *
+ * Environment:
+ *   AGENT_PROVIDER - Set to override default provider (default: "claude-code")
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeProvider = exports.isProviderAvailable = exports.registerProvider = exports.getAvailableProviders = exports.getDefaultProviderType = exports.createAgentProvider = void 0;
+// Factory
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "createAgentProvider", { enumerable: true, get: function () { return factory_1.createAgentProvider; } });
+Object.defineProperty(exports, "getDefaultProviderType", { enumerable: true, get: function () { return factory_1.getDefaultProviderType; } });
+Object.defineProperty(exports, "getAvailableProviders", { enumerable: true, get: function () { return factory_1.getAvailableProviders; } });
+Object.defineProperty(exports, "registerProvider", { enumerable: true, get: function () { return factory_1.registerProvider; } });
+Object.defineProperty(exports, "isProviderAvailable", { enumerable: true, get: function () { return factory_1.isProviderAvailable; } });
+// Built-in provider
+var claude_code_1 = require("./providers/claude-code");
+Object.defineProperty(exports, "ClaudeCodeProvider", { enumerable: true, get: function () { return claude_code_1.ClaudeCodeProvider; } });

package/dist/core/agent/providers/claude-code.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Claude Code Agent Provider
+ *
+ * Uses the Claude Agent SDK (@anthropic-ai/claude-agent-sdk) to process requests.
+ * This provider leverages Claude Code's built-in tools (Bash, Read, Write, etc.)
+ */
+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.ClaudeCodeProvider = void 0;
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+const logger_1 = require("../../logger");
+const log = (0, logger_1.createLogger)("ClaudeCodeProvider");
+class ClaudeCodeProvider {
+    name = "claude-code";
+    version = "1.0.0";
+    defaultTools = ["Bash", "Read", "Write", "Edit", "Glob", "Grep"];
+    async query(prompt, options) {
+        let result = "";
+        let sessionId;
+        for await (const event of this.queryStream(prompt, options)) {
+            if (event.type === "done" && event.response) {
+                return event.response;
+            }
+            if (event.type === "text" && event.text) {
+                result = event.text;
+            }
+        }
+        return { text: result, sessionId };
+    }
+    async *queryStream(prompt, options) {
+        const queryOptions = {
+            systemPrompt: options?.systemPrompt,
+            cwd: options?.workingDir || process.env.WORKING_DIR || process.env.HOME || "/",
+            allowedTools: options?.allowedTools || this.defaultTools,
+            permissionMode: "bypassPermissions",
+            maxTurns: options?.maxTurns || 10,
+        };
+        // Resume session if provided
+        if (options?.sessionId) {
+            queryOptions.resume = options.sessionId;
+            log.debug("Resuming session", { sessionId: options.sessionId });
+        }
+        let result = "";
+        let sessionId;
+        let usedTools = false;
+        try {
+            yield { type: "thinking" };
+            for await (const message of (0, claude_agent_sdk_1.query)({ prompt, options: queryOptions })) {
+                log.debug("Agent message", { type: message.type, subtype: message.subtype });
+                // Capture session ID from init message
+                if (message.type === "system" && message.subtype === "init") {
+                    sessionId = message.session_id;
+                    log.debug("Got session ID", { sessionId });
+                }
+                // Handle result messages
+                if ("result" in message && message.result) {
+                    result = message.result;
+                }
+                // Handle assistant text messages
+                if (message.type === "assistant" && "content" in message) {
+                    const content = message.content;
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === "text" && block.text) {
+                                result = block.text;
+                                yield { type: "text", text: block.text };
+                            }
+                            if (block.type === "tool_use") {
+                                usedTools = true;
+                                yield {
+                                    type: "tool_use",
+                                    toolName: block.name,
+                                    toolInput: block.input,
+                                };
+                            }
+                        }
+                    }
+                }
+                // Handle tool results
+                if (message.type === "user" && "content" in message) {
+                    const content = message.content;
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === "tool_result") {
+                                yield {
+                                    type: "tool_result",
+                                    toolResult: typeof block.content === "string"
+                                        ? block.content
+                                        : JSON.stringify(block.content),
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            yield {
+                type: "done",
+                response: {
+                    text: result || "Task completed (no output)",
+                    sessionId,
+                    usedTools,
+                },
+            };
+        }
+        catch (error) {
+            log.error("Query failed", { error: error.message });
+            yield { type: "error", error: error.message };
+        }
+    }
+    async isAvailable() {
+        try {
+            // Check if claude CLI is available
+            const { exec } = await Promise.resolve().then(() => __importStar(require("child_process")));
+            const { promisify } = await Promise.resolve().then(() => __importStar(require("util")));
+            const execAsync = promisify(exec);
+            await execAsync("which claude");
+            return true;
+        }
+        catch {
+            log.warn("Claude Code CLI not found");
+            return false;
+        }
+    }
+}
+exports.ClaudeCodeProvider = ClaudeCodeProvider;

package/dist/core/agent/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Agent Provider Abstraction
+ *
+ * This module defines the interface for AI agent providers.
+ * Implement this interface to add support for different AI backends
+ * (Claude Code, OpenAI, local LLMs, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/approval.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approvalManager = exports.ApprovalManager = void 0;
+const events_1 = require("events");
+const logger_1 = require("./logger");
+const platform_1 = require("./platform");
+const log = (0, logger_1.createLogger)("Approval");
+// Protected folders that require approval (platform-aware)
+const PROTECTED_FOLDERS = (0, platform_1.getProtectedFolderPatterns)();
+class ApprovalManager extends events_1.EventEmitter {
+    pendingActions = new Map();
+    notifiers = [];
+    autoApprovePatterns = [];
+    defaultTimeoutMs = 5 * 60 * 1000; // 5 minutes
+    approvedFolders = new Set(); // Folders approved in this session
+    requireApprovalForAll;
+    constructor() {
+        super();
+        this.requireApprovalForAll = process.env.REQUIRE_APPROVAL_FOR_ALL === "true";
+        // Load pre-approved folders from env
+        const allowedFolders = process.env.ALLOWED_FOLDERS?.split(":").filter(Boolean) || [];
+        allowedFolders.forEach(folder => this.approvedFolders.add(folder));
+    }
+    // Check if a path requires folder access approval
+    isProtectedPath(filePath) {
+        // If folder is already approved in this session, no approval needed
+        for (const approved of this.approvedFolders) {
+            if (filePath.startsWith(approved)) {
+                return false;
+            }
+        }
+        // Check against protected folder patterns
+        return PROTECTED_FOLDERS.some(pattern => pattern.test(filePath));
+    }
+    // Mark a folder as approved for this session
+    approveFolder(folderPath) {
+        this.approvedFolders.add(folderPath);
+        log.info("Folder approved for session", { folderPath });
+    }
+    // Request approval for folder access
+    async requestFolderAccess(filePath) {
+        if (!this.isProtectedPath(filePath)) {
+            return true; // Not protected, no approval needed
+        }
+        // Extract the base protected folder from the path
+        const baseFolder = (0, platform_1.extractBaseFolder)(filePath) || filePath;
+        const approved = await this.requestApproval("folder_access", `Access to ${baseFolder}`, { path: filePath, baseFolder }, { autoApprove: false, timeoutMs: 2 * 60 * 1000 } // 2 minute timeout
+        );
+        if (approved) {
+            this.approveFolder(baseFolder);
+        }
+        return approved;
+    }
+    addNotifier(notifier) {
+        this.notifiers.push(notifier);
+    }
+    addAutoApprovePattern(pattern) {
+        this.autoApprovePatterns.push(pattern);
+    }
+    shouldAutoApprove(action) {
+        // If require approval for all is set, never auto-approve
+        if (this.requireApprovalForAll) {
+            return false;
+        }
+        // Folder access always requires explicit approval
+        if (action.type === "folder_access") {
+            return false;
+        }
+        if (action.type === "command") {
+            const cmd = action.details.command;
+            // Safe read-only commands
+            const safeCommands = [
+                /^ls\b/,
+                /^pwd$/,
+                /^whoami$/,
+                /^date$/,
+                /^cat\s/,
+                /^head\s/,
+                /^tail\s/,
+                /^wc\s/,
+                /^du\s/,
+                /^df\s/,
+                /^echo\s/,
+                /^which\s/,
+                /^type\s/,
+                /^file\s/,
+                /^stat\s/,
+                /^uname/,
+                /^hostname$/,
+                /^uptime$/,
+                /^ps\b/,
+                /^top\s+-l\s+1/,
+                /^docker\s+ps/,
+                /^docker\s+images/,
+                /^git\s+status/,
+                /^git\s+log/,
+                /^git\s+branch/,
+                /^git\s+diff/,
+                /^npm\s+list/,
+                /^node\s+-v/,
+                /^python\s+--version/,
+            ];
+            for (const pattern of [...safeCommands, ...this.autoApprovePatterns]) {
+                if (pattern.test(cmd)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    async requestApproval(type, description, details, options) {
+        const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const timeoutMs = options?.timeoutMs || this.defaultTimeoutMs;
+        const action = {
+            id,
+            type,
+            description,
+            details,
+            createdAt: new Date(),
+            expiresAt: new Date(Date.now() + timeoutMs),
+            resolve: () => { }, // Will be set below
+        };
+        // Check for auto-approve
+        if (options?.autoApprove !== false && this.shouldAutoApprove(action)) {
+            log.info("Action auto-approved", { id, type, description });
+            log.debug("Auto-approved action details", { details });
+            this.emit("auto-approved", action);
+            return true;
+        }
+        log.info("Approval requested", { id, type, description, expiresAt: action.expiresAt });
+        // Create a promise that will be resolved when approved/rejected
+        const approvalPromise = new Promise((resolve) => {
+            action.resolve = resolve;
+        });
+        this.pendingActions.set(id, action);
+        // Set up timeout
+        const timeout = setTimeout(() => {
+            if (this.pendingActions.has(id)) {
+                log.warn("Approval request expired", { id, type, description });
+                this.pendingActions.delete(id);
+                action.resolve(false);
+                this.emit("expired", action);
+            }
+        }, timeoutMs);
+        // Notify all registered notifiers
+        for (const notifier of this.notifiers) {
+            try {
+                await notifier(action);
+            }
+            catch (error) {
+                console.error("Notifier error:", error);
+            }
+        }
+        this.emit("pending", action);
+        // Wait for approval
+        const result = await approvalPromise;
+        clearTimeout(timeout);
+        this.pendingActions.delete(id);
+        return result;
+    }
+    approve(actionId) {
+        const action = this.pendingActions.get(actionId);
+        if (action) {
+            log.info("Action approved", { id: actionId, type: action.type, description: action.description });
+            action.resolve(true);
+            this.emit("approved", action);
+            return true;
+        }
+        log.warn("Attempted to approve unknown action", { actionId });
+        return false;
+    }
+    reject(actionId) {
+        const action = this.pendingActions.get(actionId);
+        if (action) {
+            log.info("Action rejected", { id: actionId, type: action.type, description: action.description });
+            action.resolve(false);
+            this.emit("rejected", action);
+            return true;
+        }
+        log.warn("Attempted to reject unknown action", { actionId });
+        return false;
+    }
+    getPendingActions() {
+        return Array.from(this.pendingActions.values());
+    }
+    getPendingAction(id) {
+        return this.pendingActions.get(id);
+    }
+}
+exports.ApprovalManager = ApprovalManager;
+// Singleton instance
+exports.approvalManager = new ApprovalManager();