lazy-gravity 0.2.0 → 0.3.0

package/dist/utils/configLoader.js

@@ -75,17 +75,25 @@ function readPersistedConfig(filePath) {
  * Returns a fresh AppConfig object (immutable pattern).
  */
 function mergeConfig(persisted) {
-    const token = process.env.DISCORD_BOT_TOKEN ?? persisted.discordToken;
-    if (!token) {
-        throw new Error('Missing required environment variable: DISCORD_BOT_TOKEN');
-    }
-    const clientId = process.env.CLIENT_ID ?? persisted.clientId;
-    if (!clientId) {
-        throw new Error('Missing required environment variable: CLIENT_ID');
-    }
-    const allowedUserIds = resolveAllowedUserIds(persisted);
-    if (allowedUserIds.length === 0) {
-        throw new Error('Missing required environment variable: ALLOWED_USER_IDS');
+    // Resolve platforms FIRST so we only validate credentials for enabled platforms
+    const platforms = resolvePlatforms(process.env.PLATFORMS, persisted.platforms);
+    // Discord credentials — only required when Discord is an active platform
+    let discordToken;
+    let clientId;
+    let allowedUserIds = [];
+    if (platforms.includes('discord')) {
+        discordToken = process.env.DISCORD_BOT_TOKEN ?? persisted.discordToken;
+        if (!discordToken) {
+            throw new Error('Missing required environment variable: DISCORD_BOT_TOKEN');
+        }
+        clientId = process.env.CLIENT_ID ?? persisted.clientId;
+        if (!clientId) {
+            throw new Error('Missing required environment variable: CLIENT_ID');
+        }
+        allowedUserIds = resolveAllowedUserIds(persisted);
+        if (allowedUserIds.length === 0) {
+            throw new Error('Missing required environment variable: ALLOWED_USER_IDS');
+        }
     }
     const defaultDir = path.join(os.homedir(), 'Code');
     const rawDir = process.env.WORKSPACE_BASE_DIR ?? persisted.workspaceBaseDir ?? defaultDir;
@@ -94,8 +102,14 @@ function mergeConfig(persisted) {
     const autoApproveFileEdits = resolveBoolean(process.env.AUTO_APPROVE_FILE_EDITS, persisted.autoApproveFileEdits, false);
     const logLevel = resolveLogLevel(process.env.LOG_LEVEL, persisted.logLevel);
     const extractionMode = resolveExtractionMode(process.env.EXTRACTION_MODE, persisted.extractionMode);
+    // Telegram credentials — only required when Telegram is an active platform
+    const telegramToken = process.env.TELEGRAM_BOT_TOKEN ?? persisted.telegramToken ?? undefined;
+    const telegramAllowedUserIds = resolveTelegramAllowedUserIds(persisted);
+    if (platforms.includes('telegram') && !telegramToken) {
+        throw new Error('TELEGRAM_BOT_TOKEN is required when platforms include "telegram"');
+    }
     return {
-        discordToken: token,
+        discordToken,
         clientId,
         guildId,
         allowedUserIds,
@@ -103,6 +117,9 @@ function mergeConfig(persisted) {
         autoApproveFileEdits,
         logLevel,
         extractionMode,
+        telegramToken,
+        telegramAllowedUserIds,
+        platforms,
     };
 }
 function resolveAllowedUserIds(persisted) {
@@ -132,6 +149,36 @@ function resolveExtractionMode(envValue, persistedValue) {
         return 'legacy';
     return 'structured';
 }
+function resolveTelegramAllowedUserIds(persisted) {
+    const envValue = process.env.TELEGRAM_ALLOWED_USER_IDS;
+    if (envValue) {
+        return envValue
+            .split(',')
+            .map((id) => id.trim())
+            .filter((id) => id.length > 0);
+    }
+    if (persisted.telegramAllowedUserIds && persisted.telegramAllowedUserIds.length > 0) {
+        return [...persisted.telegramAllowedUserIds];
+    }
+    return undefined;
+}
+const VALID_PLATFORMS = ['discord', 'telegram'];
+function resolvePlatforms(envValue, persistedValue) {
+    if (envValue) {
+        const parsed = envValue
+            .split(',')
+            .map((p) => p.trim().toLowerCase())
+            .filter((p) => VALID_PLATFORMS.includes(p));
+        if (parsed.length > 0)
+            return parsed;
+    }
+    if (persistedValue && persistedValue.length > 0) {
+        const validated = persistedValue.filter((p) => VALID_PLATFORMS.includes(p));
+        if (validated.length > 0)
+            return validated;
+    }
+    return ['discord'];
+}
 function resolveBoolean(envValue, persistedValue, defaultValue) {
     if (envValue !== undefined)
         return envValue.toLowerCase() === 'true';
@@ -153,6 +200,10 @@ exports.ConfigLoader = {
     configExists() {
         return fs.existsSync(getConfigFilePath());
     },
+    /** Read persisted config from disk. Returns empty object if file doesn't exist. */
+    readPersisted() {
+        return readPersistedConfig(getConfigFilePath());
+    },
     /**
      * Load config using resolution order:
      *   env vars  >  ~/.lazy-gravity/config.json  >  .env  >  defaults

package/dist/utils/lockfile.js

@@ -24,7 +24,7 @@ function isProcessRunning(pid) {
  * Stop an existing process and wait for it to exit
  */
 function killExistingProcess(pid) {
-    logger_1.logger.error(`🔄 Stopping existing Bot process (PID: ${pid})...`);
+    logger_1.logger.warn(`🔄 Stopping existing Bot process (PID: ${pid})...`);
     try {
         process.kill(pid, 'SIGTERM');
     }
@@ -36,7 +36,7 @@ function killExistingProcess(pid) {
     const deadline = Date.now() + 5000;
     while (Date.now() < deadline) {
         if (!isProcessRunning(pid)) {
-            logger_1.logger.error(`✅ Existing process (PID: ${pid}) stopped`);
+            logger_1.logger.info(`✅ Existing process (PID: ${pid}) stopped`);
             return;
         }
         // Wait 50ms (busy wait)
@@ -44,7 +44,7 @@ function killExistingProcess(pid) {
         while (Date.now() < waitUntil) { /* spin */ }
     }
     // Timeout: force kill with SIGKILL
-    logger_1.logger.error(`⚠️  Process did not exit with SIGTERM, force killing (SIGKILL)`);
+    logger_1.logger.warn(`⚠️  Process did not exit with SIGTERM, force killing (SIGKILL)`);
     try {
         process.kill(pid, 'SIGKILL');
     }
@@ -78,7 +78,7 @@ function acquireLock() {
     }
     // Create new lock file
     fs_1.default.writeFileSync(LOCK_FILE, String(process.pid), 'utf-8');
-    logger_1.logger.error(`🔒 Lock acquired (PID: ${process.pid})`);
+    logger_1.logger.info(`🔒 Lock acquired (PID: ${process.pid})`);
     // Cleanup function
     const releaseLock = () => {
         try {
@@ -86,7 +86,7 @@ function acquireLock() {
                 const content = fs_1.default.readFileSync(LOCK_FILE, 'utf-8').trim();
                 if (parseInt(content, 10) === process.pid) {
                     fs_1.default.unlinkSync(LOCK_FILE);
-                    logger_1.logger.error(`🔓 Lock released (PID: ${process.pid})`);
+                    logger_1.logger.info(`🔓 Lock released (PID: ${process.pid})`);
                 }
             }
         }

package/dist/utils/logger.js

@@ -9,6 +9,7 @@ exports.COLORS = {
     cyan: '\x1b[36m',
     green: '\x1b[32m',
     magenta: '\x1b[35m',
+    boldYellow: '\x1b[1;33m',
     dim: '\x1b[2m',
     reset: '\x1b[0m',
 };
@@ -74,6 +75,12 @@ function createLogger(initialLevel = 'info') {
                 logBuffer_1.logBuffer.append('info', `[DONE] ${args.join(' ')}`);
             }
         },
+        /** User prompt text - always visible regardless of log level */
+        prompt(text) {
+            const formatted = `${getTimestamp()} ${exports.COLORS.boldYellow}[PROMPT]${exports.COLORS.reset} ${exports.COLORS.boldYellow}${text}${exports.COLORS.reset}`;
+            console.info(formatted);
+            logBuffer_1.logBuffer.append('info', `[PROMPT] ${text}`);
+        },
         /** Section divider with optional label for structured output */
         divider(label) {
             if (shouldLog('info')) {

package/dist/utils/telegramImageHandler.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Telegram image download utility.
+ *
+ * Downloads photos from Telegram Bot API and saves them to a temp directory,
+ * producing InboundImageAttachment[] that can be passed to
+ * cdp.injectMessageWithImageFiles().
+ *
+ * Reuses shared types and helpers from imageHandler.ts.
+ */
+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.downloadTelegramPhotos = downloadTelegramPhotos;
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const imageHandler_1 = require("./imageHandler");
+const logger_1 = require("./logger");
+const MAX_TELEGRAM_IMAGE_ATTACHMENTS = 4;
+const TEMP_IMAGE_DIR = path.join(os.tmpdir(), 'lazy-gravity-images');
+/**
+ * Extract the Telegram file_id from a telegram-file:// URL.
+ * Returns null if the URL doesn't match the expected scheme.
+ */
+function extractFileId(url) {
+    const prefix = 'telegram-file://';
+    if (!url.startsWith(prefix))
+        return null;
+    return url.slice(prefix.length);
+}
+/**
+ * Download Telegram photo attachments to local temp files.
+ *
+ * Uses the Telegram Bot API getFile endpoint to resolve file_id → file_path,
+ * then downloads the file via https://api.telegram.org/file/bot<token>/<path>.
+ *
+ * @param attachments - PlatformAttachment[] from the wrapped Telegram message
+ * @param botToken - The bot token for constructing download URLs
+ * @param api - The bot API object (needs getFile method)
+ * @returns Downloaded images as InboundImageAttachment[]
+ */
+async function downloadTelegramPhotos(attachments, botToken, api) {
+    if (!api.getFile) {
+        logger_1.logger.warn('[TelegramImageHandler] bot.api.getFile is not available');
+        return [];
+    }
+    const imageAttachments = attachments
+        .filter((att) => (att.contentType || '').startsWith('image/'))
+        .slice(0, MAX_TELEGRAM_IMAGE_ATTACHMENTS);
+    if (imageAttachments.length === 0)
+        return [];
+    await fs.mkdir(TEMP_IMAGE_DIR, { recursive: true });
+    const downloaded = [];
+    for (let i = 0; i < imageAttachments.length; i++) {
+        const attachment = imageAttachments[i];
+        const fileId = extractFileId(attachment.url);
+        if (!fileId) {
+            logger_1.logger.warn(`[TelegramImageHandler] Invalid file URL: ${attachment.url}`);
+            continue;
+        }
+        try {
+            // Resolve file_id to file_path via Bot API
+            const fileInfo = await api.getFile(fileId);
+            if (!fileInfo.file_path) {
+                logger_1.logger.warn(`[TelegramImageHandler] No file_path returned for file_id=${fileId}`);
+                continue;
+            }
+            // Download the file
+            const downloadUrl = `https://api.telegram.org/file/bot${botToken}/${fileInfo.file_path}`;
+            const response = await fetch(downloadUrl);
+            if (!response.ok) {
+                logger_1.logger.warn(`[TelegramImageHandler] Download failed (file_id=${fileId}, status=${response.status})`);
+                continue;
+            }
+            const bytes = Buffer.from(await response.arrayBuffer());
+            if (bytes.length === 0)
+                continue;
+            const mimeType = attachment.contentType || 'image/jpeg';
+            const ext = (0, imageHandler_1.mimeTypeToExtension)(mimeType);
+            const name = (0, imageHandler_1.sanitizeFileName)(attachment.name || `telegram-photo-${i + 1}.${ext}`);
+            const localPath = path.join(TEMP_IMAGE_DIR, `${Date.now()}-tg-${i}-${name}`);
+            await fs.writeFile(localPath, bytes);
+            downloaded.push({
+                localPath,
+                url: downloadUrl,
+                name,
+                mimeType,
+            });
+        }
+        catch (error) {
+            logger_1.logger.warn(`[TelegramImageHandler] Failed to download photo (file_id=${fileId}):`, error?.message || error);
+        }
+    }
+    return downloaded;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lazy-gravity",
-  "version": "0.2.0",
-  "description": "Control Antigravity from anywhere — a local, secure Discord Bot that lets you remotely operate Antigravity on your home PC from your smartphone's Discord app.",
+  "version": "0.3.0",
+  "description": "Control Antigravity from anywhere — a local, secure bot (Discord + Telegram) that lets you remotely operate Antigravity on your home PC from your smartphone.",
   "main": "dist/index.js",
   "bin": {
     "lazy-gravity": "dist/bin/cli.js"
@@ -47,10 +47,12 @@
   },
   "homepage": "https://github.com/tokyoweb3/LazyGravity#readme",
   "dependencies": {
+    "@inquirer/select": "^4.4.2",
     "better-sqlite3": "^12.6.2",
     "commander": "^14.0.3",
     "discord.js": "^14.25.1",
     "dotenv": "^17.3.1",
+    "grammy": "^1.41.1",
     "node-cron": "^4.2.1",
     "ws": "^8.19.0"
   },