@sarkar-ai/deskmate 0.2.0

package/dist/cli/init.js

@@ -0,0 +1,387 @@
+"use strict";
+/**
+ * Interactive Setup Wizard
+ *
+ * Self-contained setup: writes .env, optionally installs a background service
+ * (launchd on macOS, systemd on Linux), and guides through macOS permissions.
+ *
+ * For an alternative shell-based installer, see ./install.sh.
+ */
+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.runInitWizard = runInitWizard;
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function createPrompt() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+function ask(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer.trim()));
+    });
+}
+async function askYesNo(rl, question, defaultYes = true) {
+    const hint = defaultYes ? "[Y/n]" : "[y/N]";
+    const answer = await ask(rl, `${question} ${hint}: `);
+    if (answer === "")
+        return defaultYes;
+    return answer.toLowerCase() === "y";
+}
+async function checkClaudeCLI() {
+    try {
+        (0, child_process_1.execSync)("which claude", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function detectPlatform() {
+    switch (process.platform) {
+        case "darwin":
+            return "macos";
+        case "linux":
+            return "linux";
+        case "win32":
+            return "windows";
+        default:
+            return "unsupported";
+    }
+}
+// ---------------------------------------------------------------------------
+// Service installation helpers
+// ---------------------------------------------------------------------------
+const PLIST_NAME = "com.deskmate.service";
+function plistPath() {
+    return path.join(os.homedir(), "Library", "LaunchAgents", `${PLIST_NAME}.plist`);
+}
+function systemdDir() {
+    return path.join(os.homedir(), ".config", "systemd", "user");
+}
+function systemdPath() {
+    return path.join(systemdDir(), "deskmate.service");
+}
+function buildPlist(nodePath, projectDir, logsDir, runMode) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_NAME}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${projectDir}/dist/index.js</string>
+        <string>${runMode}</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>${projectDir}</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:${os.homedir()}/.local/bin</string>
+    </dict>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>StandardOutPath</key>
+    <string>${logsDir}/stdout.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>${logsDir}/stderr.log</string>
+</dict>
+</plist>`;
+}
+function buildSystemdUnit(nodePath, projectDir, logsDir, runMode) {
+    return `[Unit]
+Description=Deskmate - Local Machine Assistant
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${projectDir}/dist/index.js ${runMode}
+WorkingDirectory=${projectDir}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin:${os.homedir()}/.local/bin
+Restart=always
+RestartSec=5
+
+InhibitDelayMaxSec=5
+
+StandardOutput=append:${logsDir}/stdout.log
+StandardError=append:${logsDir}/stderr.log
+
+[Install]
+WantedBy=default.target`;
+}
+async function installMacosService(projectDir, logsDir, runMode) {
+    const nodePath = process.execPath;
+    const dest = plistPath();
+    // Unload existing
+    try {
+        (0, child_process_1.execSync)(`launchctl list 2>/dev/null | grep -q "${PLIST_NAME}" && launchctl unload "${dest}"`, {
+            stdio: "ignore",
+            shell: "/bin/bash",
+        });
+    }
+    catch {
+        // not loaded — fine
+    }
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    await fs.mkdir(logsDir, { recursive: true });
+    await fs.writeFile(dest, buildPlist(nodePath, projectDir, logsDir, runMode), "utf-8");
+    (0, child_process_1.execSync)(`launchctl load "${dest}"`);
+    console.log("\n  Service installed and started via launchd.");
+    console.log(`  Plist: ${dest}`);
+}
+async function installLinuxService(projectDir, logsDir, runMode) {
+    const nodePath = process.execPath;
+    const dest = systemdPath();
+    // Stop existing
+    try {
+        (0, child_process_1.execSync)("systemctl --user stop deskmate.service", { stdio: "ignore" });
+    }
+    catch {
+        // not running — fine
+    }
+    await fs.mkdir(systemdDir(), { recursive: true });
+    await fs.mkdir(logsDir, { recursive: true });
+    await fs.writeFile(dest, buildSystemdUnit(nodePath, projectDir, logsDir, runMode), "utf-8");
+    (0, child_process_1.execSync)("systemctl --user daemon-reload");
+    (0, child_process_1.execSync)("systemctl --user enable deskmate.service");
+    (0, child_process_1.execSync)("systemctl --user start deskmate.service");
+    // Enable lingering so the service survives logout
+    try {
+        (0, child_process_1.execSync)(`loginctl enable-linger "$(whoami)"`, { stdio: "ignore", shell: "/bin/bash" });
+    }
+    catch {
+        // loginctl may not be available
+    }
+    console.log("\n  Service installed and started via systemd.");
+    console.log(`  Unit file: ${dest}`);
+}
+// ---------------------------------------------------------------------------
+// macOS permissions helper
+// ---------------------------------------------------------------------------
+async function offerMacosPermissions(rl) {
+    console.log("\n--- macOS Permissions ---\n");
+    console.log("  Deskmate works best with the following permissions:");
+    console.log("    - Screen Recording (screenshots)");
+    console.log("    - Accessibility (system control)");
+    console.log("    - Full Disk Access (read/write anywhere)");
+    console.log("    - Automation (AppleScript)");
+    console.log("");
+    if (await askYesNo(rl, "Trigger Screen Recording permission dialog?")) {
+        try {
+            (0, child_process_1.execSync)("screencapture -x /tmp/deskmate-test-screenshot.png", { stdio: "ignore" });
+            (0, child_process_1.execSync)("rm -f /tmp/deskmate-test-screenshot.png", { stdio: "ignore" });
+        }
+        catch {
+            // permission dialog may have appeared
+        }
+        console.log("  If a dialog appeared, click Allow.\n");
+    }
+    if (await askYesNo(rl, "Open Accessibility settings?")) {
+        (0, child_process_1.execSync)('open "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility"');
+        await ask(rl, "  Press Enter when done...");
+    }
+    if (await askYesNo(rl, "Open Full Disk Access settings?")) {
+        (0, child_process_1.execSync)('open "x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles"');
+        await ask(rl, "  Press Enter when done...");
+    }
+    if (await askYesNo(rl, "Open Automation settings?")) {
+        (0, child_process_1.execSync)('open "x-apple.systempreferences:com.apple.preference.security?Privacy_Automation"');
+        await ask(rl, "  Press Enter when done...");
+    }
+}
+// ---------------------------------------------------------------------------
+// Management commands summary
+// ---------------------------------------------------------------------------
+function printManagementCommands(platform, logsDir) {
+    console.log("\nManagement commands:\n");
+    console.log(`  View logs:        tail -f ${logsDir}/stdout.log`);
+    if (platform === "macos") {
+        const dest = plistPath();
+        console.log(`  Stop service:     launchctl unload "${dest}"`);
+        console.log(`  Start service:    launchctl load "${dest}"`);
+        console.log(`  Check status:     launchctl list | grep deskmate`);
+    }
+    else if (platform === "linux") {
+        console.log("  Stop service:     systemctl --user stop deskmate.service");
+        console.log("  Start service:    systemctl --user start deskmate.service");
+        console.log("  Restart service:  systemctl --user restart deskmate.service");
+        console.log("  Check status:     systemctl --user status deskmate.service");
+    }
+    else if (platform === "windows") {
+        console.log("  On Windows (WSL2), manage the service from inside your WSL2 terminal.");
+        console.log("  Stop service:     systemctl --user stop deskmate.service");
+        console.log("  Start service:    systemctl --user start deskmate.service");
+    }
+}
+// ---------------------------------------------------------------------------
+// Main wizard
+// ---------------------------------------------------------------------------
+async function runInitWizard() {
+    const rl = createPrompt();
+    console.log("\n========================================");
+    console.log("  Deskmate Setup Wizard");
+    console.log("========================================\n");
+    const platform = detectPlatform();
+    console.log(`Detected platform: ${platform}\n`);
+    if (platform === "windows") {
+        console.log("Native Windows is not directly supported.");
+        console.log("Please run this wizard inside a WSL2 terminal.\n");
+    }
+    const hasClaude = await checkClaudeCLI();
+    if (!hasClaude) {
+        console.log("WARNING: 'claude' CLI not found in PATH.");
+        console.log("Install it from: https://docs.anthropic.com/en/docs/claude-code");
+        console.log("");
+    }
+    // ----- Step 1: .env wizard -----
+    const env = {};
+    env.AGENT_PROVIDER = "claude-code";
+    const apiKey = await ask(rl, "Anthropic API Key (for Claude Code): ");
+    if (apiKey)
+        env.ANTHROPIC_API_KEY = apiKey;
+    console.log("\n--- Telegram Configuration ---\n");
+    console.log("  Bot token → message @BotFather on Telegram, send /newbot");
+    console.log("  User ID   → message @userinfobot on Telegram, copy the number");
+    console.log("");
+    const token = await ask(rl, "Telegram Bot Token (from @BotFather): ");
+    if (token)
+        env.TELEGRAM_BOT_TOKEN = token;
+    const userId = await ask(rl, "Your Telegram User ID (from @userinfobot): ");
+    if (userId) {
+        env.ALLOWED_USER_ID = userId;
+        env.ALLOWED_USERS = `telegram:${userId}`;
+    }
+    console.log("\n--- General Configuration ---\n");
+    const workingDir = await ask(rl, `Working directory (default: ${os.homedir()}): `);
+    if (workingDir)
+        env.WORKING_DIR = workingDir;
+    const botName = await ask(rl, "Bot name (default: Deskmate): ");
+    if (botName)
+        env.BOT_NAME = botName;
+    // ----- Step 2: Write .env -----
+    const envPath = path.join(process.cwd(), ".env");
+    let envContent = "# Deskmate Configuration (generated by deskmate init)\n\n";
+    for (const [key, value] of Object.entries(env)) {
+        envContent += `${key}=${value}\n`;
+    }
+    if (!env.LOG_LEVEL)
+        envContent += "LOG_LEVEL=info\n";
+    if (!env.REQUIRE_APPROVAL_FOR_ALL)
+        envContent += "REQUIRE_APPROVAL_FOR_ALL=false\n";
+    try {
+        let envExists = false;
+        try {
+            await fs.access(envPath);
+            envExists = true;
+        }
+        catch {
+            // does not exist
+        }
+        if (envExists) {
+            console.log(`\nWARNING: .env file already exists at ${envPath}`);
+            const newPath = envPath + ".new";
+            await fs.writeFile(newPath, envContent, "utf-8");
+            console.log(`Configuration saved to ${newPath}`);
+            console.log("Review and rename it to .env when ready.");
+        }
+        else {
+            await fs.writeFile(envPath, envContent, "utf-8");
+            console.log(`\nConfiguration saved to ${envPath}`);
+        }
+    }
+    catch (error) {
+        console.error(`\nFailed to write config: ${error.message}`);
+        console.log("\nHere is your configuration:\n");
+        console.log(envContent);
+    }
+    // ----- Step 3: Service installation -----
+    if (platform === "macos" || platform === "linux") {
+        console.log("");
+        const installService = await askYesNo(rl, "Install as background service?");
+        if (installService) {
+            // Determine project root (where package.json lives)
+            const projectDir = path.resolve(__dirname, "..");
+            const logsDir = path.join(projectDir, "logs");
+            const runMode = "gateway";
+            try {
+                if (platform === "macos") {
+                    await installMacosService(projectDir, logsDir, runMode);
+                }
+                else {
+                    await installLinuxService(projectDir, logsDir, runMode);
+                }
+            }
+            catch (err) {
+                console.error(`\n  Failed to install service: ${err.message}`);
+                console.log("  You can install manually with ./install.sh");
+            }
+            // macOS permissions
+            if (platform === "macos") {
+                const setupPerms = await askYesNo(rl, "\nConfigure macOS permissions?");
+                if (setupPerms) {
+                    await offerMacosPermissions(rl);
+                }
+            }
+            printManagementCommands(platform, logsDir);
+        }
+    }
+    else if (platform === "windows") {
+        console.log("\nTo run as a service on Windows, open a WSL2 terminal and run: deskmate init");
+    }
+    rl.close();
+    console.log("\nSetup complete! Your bot is ready.");
+    console.log("");
+}

package/dist/cli.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+"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.buildAllowedUsers = buildAllowedUsers;
+require("dotenv/config");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"));
+const VERSION = pkg.version;
+const BOT_NAME = process.env.BOT_NAME || "Deskmate";
+function printHelp() {
+    console.log(`
+${BOT_NAME} - Control your machine from anywhere using natural language
+
+Usage:
+  deskmate <command> [options]
+
+Commands:
+  telegram    Start the Telegram bot (default)
+  mcp         Start the MCP server
+  both        Start both Telegram bot and MCP server
+  gateway     Start the multi-client gateway
+  init        Interactive setup wizard
+
+Options:
+  -h, --help      Show this help message
+  -v, --version   Show version number
+
+Examples:
+  deskmate                  Start in Telegram mode
+  deskmate telegram         Start the Telegram bot
+  deskmate mcp              Start the MCP server
+  deskmate gateway          Start multi-client gateway
+  deskmate init             Run the setup wizard
+  deskmate --version        Print version
+
+Environment:
+  AGENT_PROVIDER            Agent provider (default: claude-code)
+  TELEGRAM_BOT_TOKEN        Telegram bot token
+  ANTHROPIC_API_KEY         Anthropic API key
+  ALLOWED_USERS             Multi-client allowlist (e.g. telegram:123,discord:456)
+`);
+}
+function buildAllowedUsers() {
+    const users = [];
+    const multiClient = process.env.ALLOWED_USERS;
+    if (multiClient) {
+        for (const entry of multiClient.split(",").map((s) => s.trim()).filter(Boolean)) {
+            const colonIdx = entry.indexOf(":");
+            if (colonIdx > 0) {
+                users.push({
+                    clientType: entry.slice(0, colonIdx),
+                    platformUserId: entry.slice(colonIdx + 1),
+                });
+            }
+        }
+    }
+    const legacyId = process.env.ALLOWED_USER_ID;
+    if (legacyId && legacyId !== "0") {
+        const alreadyHas = users.some((u) => u.clientType === "telegram" && u.platformUserId === legacyId);
+        if (!alreadyHas) {
+            users.push({ clientType: "telegram", platformUserId: legacyId });
+        }
+    }
+    return users;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args.find((a) => !a.startsWith("-")) || "telegram";
+    const flags = new Set(args.filter((a) => a.startsWith("-")));
+    if (flags.has("--help") || flags.has("-h")) {
+        printHelp();
+        process.exit(0);
+    }
+    if (flags.has("--version") || flags.has("-v")) {
+        console.log(VERSION);
+        process.exit(0);
+    }
+    // If no explicit command and no .env found, suggest running init
+    if (!args.find((a) => !a.startsWith("-")) &&
+        !fs.existsSync(path.join(process.cwd(), ".env"))) {
+        console.log(`No .env file found. Run "deskmate init" to get started.\n`);
+    }
+    switch (command) {
+        case "telegram": {
+            console.log(`Starting ${BOT_NAME} in telegram mode...`);
+            const { startTelegramBot } = await Promise.resolve().then(() => __importStar(require("./telegram/bot")));
+            await startTelegramBot();
+            break;
+        }
+        case "mcp": {
+            console.log(`Starting ${BOT_NAME} in mcp mode...`);
+            const { startMcpServer } = await Promise.resolve().then(() => __importStar(require("./mcp/server")));
+            await startMcpServer();
+            break;
+        }
+        case "both": {
+            console.log(`Starting ${BOT_NAME} in both mode...`);
+            const [{ startTelegramBot: startBot }, { startMcpServer: startMcp }] = await Promise.all([
+                Promise.resolve().then(() => __importStar(require("./telegram/bot"))),
+                Promise.resolve().then(() => __importStar(require("./mcp/server"))),
+            ]);
+            startBot().catch(console.error);
+            await startMcp();
+            break;
+        }
+        case "gateway": {
+            console.log(`Starting ${BOT_NAME} in gateway mode...`);
+            const { Gateway } = await Promise.resolve().then(() => __importStar(require("./gateway")));
+            const { TelegramClient } = await Promise.resolve().then(() => __importStar(require("./clients/telegram")));
+            const allowedUsers = buildAllowedUsers();
+            if (allowedUsers.length === 0) {
+                console.error("No allowed users configured. Set ALLOWED_USERS or ALLOWED_USER_ID in your .env");
+                process.exit(1);
+            }
+            const gateway = new Gateway({
+                botName: BOT_NAME,
+                workingDir: process.env.WORKING_DIR || process.env.HOME || "/",
+                allowedUsers,
+                maxTurns: 10,
+            });
+            if (process.env.TELEGRAM_BOT_TOKEN) {
+                gateway.registerClient(new TelegramClient(process.env.TELEGRAM_BOT_TOKEN));
+            }
+            await gateway.start();
+            break;
+        }
+        case "setup":
+        case "init": {
+            const { runInitWizard } = await Promise.resolve().then(() => __importStar(require("./cli/init")));
+            await runInitWizard();
+            break;
+        }
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.error('Run "deskmate --help" for usage information.');
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+process.on("SIGINT", () => {
+    console.log("\nShutting down...");
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    console.log("\nShutting down...");
+    process.exit(0);
+});