lazy-gravity 0.0.2 → 0.0.3

package/dist/utils/lockfile.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireLock = acquireLock;
+const logger_1 = require("./logger");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const LOCK_FILE = path_1.default.resolve(process.cwd(), '.bot.lock');
+/**
+ * Check if a process with the given PID is running
+ */
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Stop an existing process and wait for it to exit
+ */
+function killExistingProcess(pid) {
+    logger_1.logger.error(`🔄 Stopping existing Bot process (PID: ${pid})...`);
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        // Ignore if already terminated
+        return;
+    }
+    // Wait up to 5 seconds for process to exit
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        if (!isProcessRunning(pid)) {
+            logger_1.logger.error(`✅ Existing process (PID: ${pid}) stopped`);
+            return;
+        }
+        // Wait 50ms (busy wait)
+        const waitUntil = Date.now() + 50;
+        while (Date.now() < waitUntil) { /* spin */ }
+    }
+    // Timeout: force kill with SIGKILL
+    logger_1.logger.error(`⚠️  Process did not exit with SIGTERM, force killing (SIGKILL)`);
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch {
+        // ignore
+    }
+}
+/**
+ * Acquire a lockfile to prevent duplicate bot instances.
+ * If another process is already running, stop it before starting.
+ *
+ * @returns A function to release the lock
+ */
+function acquireLock() {
+    // Check existing lock file
+    if (fs_1.default.existsSync(LOCK_FILE)) {
+        const content = fs_1.default.readFileSync(LOCK_FILE, 'utf-8').trim();
+        const existingPid = parseInt(content, 10);
+        if (!isNaN(existingPid) && existingPid !== process.pid && isProcessRunning(existingPid)) {
+            // Stop existing process and restart
+            killExistingProcess(existingPid);
+        }
+        else if (!isNaN(existingPid) && !isProcessRunning(existingPid)) {
+            logger_1.logger.warn(`⚠️  Stale lock file detected (PID: ${existingPid} has exited). Cleaning up.`);
+        }
+        // Remove stale lock file
+        try {
+            fs_1.default.unlinkSync(LOCK_FILE);
+        }
+        catch { /* ignore */ }
+    }
+    // Create new lock file
+    fs_1.default.writeFileSync(LOCK_FILE, String(process.pid), 'utf-8');
+    logger_1.logger.error(`🔒 Lock acquired (PID: ${process.pid})`);
+    // Cleanup function
+    const releaseLock = () => {
+        try {
+            if (fs_1.default.existsSync(LOCK_FILE)) {
+                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})`);
+                }
+            }
+        }
+        catch {
+            // Ignore errors during cleanup
+        }
+    };
+    // Auto cleanup on process exit
+    process.on('exit', releaseLock);
+    process.on('SIGINT', () => {
+        releaseLock();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        releaseLock();
+        process.exit(0);
+    });
+    process.on('uncaughtException', (err) => {
+        logger_1.logger.error('Uncaught exception:', err);
+        releaseLock();
+        process.exit(1);
+    });
+    return releaseLock;
+}

package/dist/utils/logger.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const COLORS = {
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+    magenta: '\x1b[35m',
+    dim: '\x1b[2m',
+    reset: '\x1b[0m',
+};
+exports.logger = {
+    info: (...args) => console.info(`${COLORS.cyan}[INFO]${COLORS.reset}`, ...args),
+    warn: (...args) => console.warn(`${COLORS.yellow}[WARN]${COLORS.reset}`, ...args),
+    error: (...args) => console.error(`${COLORS.red}[ERROR]${COLORS.reset}`, ...args),
+    debug: (...args) => console.debug(`${COLORS.dim}[DEBUG]${COLORS.reset}`, ...args),
+    /** Important state transitions — stands out in logs */
+    phase: (...args) => console.info(`${COLORS.magenta}[PHASE]${COLORS.reset}`, ...args),
+    /** Completion-related events — green for success */
+    done: (...args) => console.info(`${COLORS.green}[DONE]${COLORS.reset}`, ...args),
+    /** Section divider with optional label for structured output */
+    divider: (label) => {
+        if (label) {
+            const pad = Math.max(4, 50 - label.length - 4);
+            console.info(`${COLORS.green}[DONE]${COLORS.reset} ${COLORS.dim}── ${label} ${'─'.repeat(pad)}${COLORS.reset}`);
+        }
+        else {
+            console.info(`${COLORS.green}[DONE]${COLORS.reset} ${COLORS.dim}${'─'.repeat(50)}${COLORS.reset}`);
+        }
+    },
+};

package/dist/utils/logo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGO = void 0;
+exports.LOGO = `
+      .           *                  .
+            /\\___/\\            z Z
+    *      ( - . - )____________z          *
+            \\_                __)
+              \\_  \\________/  /          .
+                \\__)      \\__)
+
+     ~ Booting... LazyGravity ~
+`;

package/dist/utils/metadataExtractor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMetadataFromFooter = extractMetadataFromFooter;
+function extractMetadataFromFooter(footerText) {
+    const result = {};
+    const taskIdMatch = footerText.match(/TaskID:\s*([^\s|]+)/i);
+    if (taskIdMatch && taskIdMatch[1]) {
+        result.taskId = taskIdMatch[1];
+    }
+    const dirMatch = footerText.match(/Dir:\s*([^\s|]+)/i);
+    if (dirMatch && dirMatch[1]) {
+        result.directory = dirMatch[1];
+    }
+    return result;
+}

package/dist/utils/processLogBuffer.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessLogBuffer = void 0;
+const DEFAULT_MAX_CHARS = 3500;
+const DEFAULT_MAX_ENTRIES = 120;
+const DEFAULT_MAX_ENTRY_LENGTH = 260;
+function collapseWhitespace(text) {
+    return (text || '').replace(/\r/g, '').replace(/\s+/g, ' ').trim();
+}
+function parseBlocks(raw) {
+    const normalized = (raw || '').replace(/\r/g, '').trim();
+    if (!normalized)
+        return [];
+    const blocks = normalized
+        .split(/\n{2,}/)
+        .map((chunk) => collapseWhitespace(chunk))
+        .filter((chunk) => chunk.length > 0);
+    if (blocks.length > 0)
+        return blocks;
+    return normalized
+        .split('\n')
+        .map((line) => collapseWhitespace(line))
+        .filter((line) => line.length > 0);
+}
+function pickEmoji(entry) {
+    const lower = entry.toLowerCase();
+    if (/^thought for\b/.test(lower) || /^thinking\b/.test(lower))
+        return '🧠';
+    if (/^initiating\b/.test(lower) || /^starting\b/.test(lower))
+        return '🚀';
+    if (/^[a-z0-9._-]+\s*\/\s*[a-z0-9._-]+$/i.test(entry))
+        return '🛠️';
+    if (/^title:\s/.test(lower) && /\surl:\s/.test(lower))
+        return '🔎';
+    if (/^(json|javascript|typescript|python|bash|sh|html|css|xml|yaml|yml|toml|sql|graphql|markdown|text|plaintext|log)$/i.test(entry))
+        return '📦';
+    return '•';
+}
+function toDisplayEntry(rawEntry, maxEntryLength) {
+    const trimmed = collapseWhitespace(rawEntry);
+    if (!trimmed)
+        return '';
+    const clipped = trimmed.length > maxEntryLength
+        ? `${trimmed.slice(0, Math.max(0, maxEntryLength - 3))}...`
+        : trimmed;
+    return `${pickEmoji(clipped)} ${clipped}`;
+}
+class ProcessLogBuffer {
+    maxChars;
+    maxEntries;
+    maxEntryLength;
+    entries = [];
+    seen = new Set();
+    constructor(options = {}) {
+        this.maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
+        this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+        this.maxEntryLength = options.maxEntryLength ?? DEFAULT_MAX_ENTRY_LENGTH;
+    }
+    append(raw) {
+        const blocks = parseBlocks(raw);
+        for (const block of blocks) {
+            const display = toDisplayEntry(block, this.maxEntryLength);
+            if (!display)
+                continue;
+            const key = display.toLowerCase();
+            if (this.seen.has(key))
+                continue;
+            this.entries.push(display);
+            this.seen.add(key);
+        }
+        this.trim();
+        return this.snapshot();
+    }
+    snapshot() {
+        return this.entries.join('\n');
+    }
+    trim() {
+        while (this.entries.length > this.maxEntries) {
+            this.dropOldest();
+        }
+        while (this.entries.length > 1 && this.snapshot().length > this.maxChars) {
+            this.dropOldest();
+        }
+        if (this.entries.length === 1 && this.entries[0].length > this.maxChars) {
+            const only = this.entries[0];
+            this.entries[0] = `${only.slice(0, Math.max(0, this.maxChars - 3))}...`;
+            this.seen.clear();
+            this.seen.add(this.entries[0].toLowerCase());
+        }
+    }
+    dropOldest() {
+        const removed = this.entries.shift();
+        if (!removed)
+            return;
+        this.seen.delete(removed.toLowerCase());
+    }
+}
+exports.ProcessLogBuffer = ProcessLogBuffer;

package/dist/utils/streamMessageFormatter.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModeModelLines = buildModeModelLines;
+exports.shouldSkipActivityLog = shouldSkipActivityLog;
+exports.splitForEmbedDescription = splitForEmbedDescription;
+exports.fitForSingleEmbedDescription = fitForSingleEmbedDescription;
+/**
+ * Generate mode/model lines for initial status display.
+ * Consolidates into a single line if Fast and Plan models are the same.
+ */
+function buildModeModelLines(modeName, fastModel, planModel) {
+    const lines = [`Current Mode: ${modeName}`];
+    if (fastModel.trim().toLowerCase() === planModel.trim().toLowerCase()) {
+        lines.push(`Model: ${fastModel}`);
+        return lines;
+    }
+    lines.push(`Fast Model: ${fastModel}`);
+    lines.push(`Plan Model: ${planModel}`);
+    return lines;
+}
+/**
+ * Filter out activity logs that tend to be noise in Discord display.
+ */
+function shouldSkipActivityLog(activity, modeName, modelName) {
+    const normalized = activity.trim().toLowerCase();
+    if (!normalized)
+        return true;
+    const modeLower = modeName.trim().toLowerCase();
+    const modelLower = modelName.trim().toLowerCase();
+    if (normalized === modeLower || normalized === modelLower)
+        return true;
+    if (/^(?:fast|planning|plan|generating\.*|thinking\.*|processing\.*|working\.*)$/.test(normalized)) {
+        return true;
+    }
+    // Single-word logs that tend to be noise (create / ready / pull. etc.)
+    if (/^[a-z][a-z0-9_-]{1,24}[.!…]?$/.test(normalized)) {
+        return true;
+    }
+    // Detailed trace for file reading operations (Analyzed....)
+    if (/^analyzed/.test(normalized)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Split text into multiple chunks for Embed description.
+ */
+function splitForEmbedDescription(text, maxLength = 3500) {
+    if (text.length <= maxLength)
+        return [text];
+    const lines = text.split('\n');
+    const chunks = [];
+    let current = '';
+    const flush = () => {
+        if (!current)
+            return;
+        chunks.push(current);
+        current = '';
+    };
+    for (const line of lines) {
+        const candidate = current ? `${current}\n${line}` : line;
+        if (candidate.length <= maxLength) {
+            current = candidate;
+            continue;
+        }
+        flush();
+        if (line.length <= maxLength) {
+            current = line;
+            continue;
+        }
+        let cursor = 0;
+        while (cursor < line.length) {
+            chunks.push(line.slice(cursor, cursor + maxLength));
+            cursor += maxLength;
+        }
+    }
+    flush();
+    return chunks.length > 0 ? chunks : [''];
+}
+/**
+ * Fit text within the limit for a single Embed description.
+ * When exceeding the limit, truncate the beginning and prioritize displaying the tail (most recent part).
+ */
+function fitForSingleEmbedDescription(text, maxLength = 3500) {
+    if (text.length <= maxLength)
+        return text;
+    const prefix = '... (beginning truncated)\n';
+    const tailLength = Math.max(0, maxLength - prefix.length);
+    return `${prefix}${text.slice(-tailLength)}`;
+}

package/package.json

@@ -1,6 +1,74 @@
 {
-    "name": "lazy-gravity",
-    "version": "0.0.2",
-    "description": "Reserved package name",
-    "main": "index.js"
-}
+  "name": "lazy-gravity",
+  "version": "0.0.3",
+  "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.",
+  "main": "dist/index.js",
+  "bin": {
+    "lazy-gravity": "dist/bin/cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "directories": {
+    "doc": "docs"
+  },
+  "scripts": {
+    "test": "npm run test:unit",
+    "test:unit": "jest",
+    "test:integration": "jest tests/e2e.bot.test.ts",
+    "test:watch": "jest --watch",
+    "build": "tsc",
+    "start": "ts-node src/index.ts",
+    "start:built": "node dist/bin/cli.js",
+    "dev": "ts-node-dev --respawn src/index.ts",
+    "docs:diagram": "mmdc -i docs/diagrams/architecture.mmd -o docs/images/architecture.svg -b transparent",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "keywords": [
+    "discord",
+    "bot",
+    "ai",
+    "antigravity",
+    "remote-control"
+  ],
+  "author": "LazyGravity Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tokyoweb3/LazyGravity.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tokyoweb3/LazyGravity/issues"
+  },
+  "homepage": "https://github.com/tokyoweb3/LazyGravity#readme",
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "commander": "^14.0.3",
+    "discord.js": "^14.25.1",
+    "dotenv": "^17.3.1",
+    "node-cron": "^4.2.1",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@mermaid-js/mermaid-cli": "^11.12.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.3.0",
+    "@types/node-cron": "^3.0.11",
+    "@types/ws": "^8.18.1",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "jsdom": "^28.1.0",
+    "minimatch": "^10.2.1",
+    "ts-jest": "^29.4.6",
+    "ts-morph": "^27.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "undici": "^6.23.0"
+  }
+}