clawless 0.1.2

package/dist/messaging/telegramClient.js

@@ -0,0 +1,109 @@
+import { Telegraf } from 'telegraf';
+function splitTextIntoChunks(text, maxMessageLength) {
+    const normalizedText = String(text || '');
+    if (!normalizedText) {
+        return [''];
+    }
+    if (normalizedText.length <= maxMessageLength) {
+        return [normalizedText];
+    }
+    const chunks = [];
+    let start = 0;
+    while (start < normalizedText.length) {
+        const end = Math.min(start + maxMessageLength, normalizedText.length);
+        chunks.push(normalizedText.slice(start, end));
+        start = end;
+    }
+    return chunks;
+}
+class TelegramMessageContext {
+    ctx;
+    typingIntervalMs;
+    maxMessageLength;
+    text;
+    chatId;
+    constructor(ctx, typingIntervalMs, maxMessageLength) {
+        this.ctx = ctx;
+        this.typingIntervalMs = typingIntervalMs;
+        this.maxMessageLength = maxMessageLength;
+        this.text = ctx.message?.text || '';
+        this.chatId = ctx.chat?.id;
+    }
+    startTyping() {
+        this.ctx.telegram.sendChatAction(this.ctx.chat.id, 'typing').catch(() => { });
+        const intervalId = setInterval(() => {
+            this.ctx.telegram.sendChatAction(this.ctx.chat.id, 'typing').catch(() => { });
+        }, this.typingIntervalMs);
+        return () => clearInterval(intervalId);
+    }
+    async sendText(text) {
+        const chunks = splitTextIntoChunks(text, this.maxMessageLength);
+        for (const chunk of chunks) {
+            await this.ctx.reply(chunk);
+        }
+    }
+    async startLiveMessage(initialText = '…') {
+        const sent = await this.ctx.reply(initialText);
+        return sent?.message_id;
+    }
+    async updateLiveMessage(messageId, text) {
+        await this.ctx.telegram.editMessageText(this.ctx.chat.id, messageId, undefined, text || '…');
+    }
+    async finalizeLiveMessage(messageId, text) {
+        const finalText = text || 'No response received.';
+        const chunks = splitTextIntoChunks(finalText, this.maxMessageLength);
+        try {
+            await this.updateLiveMessage(messageId, chunks[0] || 'No response received.');
+        }
+        catch (error) {
+            const errorMessage = String(error?.message || '').toLowerCase();
+            if (!errorMessage.includes('message is not modified')) {
+                throw error;
+            }
+        }
+        for (let index = 1; index < chunks.length; index += 1) {
+            await this.ctx.reply(chunks[index]);
+        }
+    }
+    async removeMessage(messageId) {
+        await this.ctx.telegram.deleteMessage(this.ctx.chat.id, messageId);
+    }
+}
+export class TelegramMessagingClient {
+    bot;
+    typingIntervalMs;
+    maxMessageLength;
+    constructor({ token, typingIntervalMs, maxMessageLength }) {
+        this.bot = new Telegraf(token);
+        this.typingIntervalMs = typingIntervalMs;
+        this.maxMessageLength = maxMessageLength;
+    }
+    onTextMessage(handler) {
+        this.bot.on('text', (ctx) => {
+            const messageContext = new TelegramMessageContext(ctx, this.typingIntervalMs, this.maxMessageLength);
+            Promise.resolve(handler(messageContext)).catch((error) => {
+                console.error('Text message handler failed:', error);
+            });
+        });
+    }
+    onError(handler) {
+        this.bot.catch((error, ctx) => {
+            const messageContext = ctx?.chat
+                ? new TelegramMessageContext(ctx, this.typingIntervalMs, this.maxMessageLength)
+                : null;
+            handler(error, messageContext);
+        });
+    }
+    async launch() {
+        await this.bot.launch();
+    }
+    async sendTextToChat(chatId, text) {
+        const chunks = splitTextIntoChunks(text, this.maxMessageLength);
+        for (const chunk of chunks) {
+            await this.bot.telegram.sendMessage(chatId, chunk);
+        }
+    }
+    stop(reason) {
+        this.bot.stop(reason);
+    }
+}

package/dist/scheduler/cronScheduler.js

@@ -0,0 +1,272 @@
+import cron from 'node-cron';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getErrorMessage } from '../utils/error.js';
+export class CronScheduler {
+    jobs = new Map();
+    jobCallback;
+    persistenceFilePath;
+    timezone;
+    logInfo;
+    constructor(callback, options = {}) {
+        this.jobCallback = callback;
+        this.persistenceFilePath = options.persistenceFilePath || null;
+        this.timezone = options.timezone || process.env.TZ || 'UTC';
+        this.logInfo = options.logInfo || ((message, details) => {
+            if (details !== undefined) {
+                console.log(`[CronScheduler] ${message}`, details);
+            }
+            else {
+                console.log(`[CronScheduler] ${message}`);
+            }
+        });
+        this.loadPersistedSchedules();
+    }
+    validateScheduleConfig(config) {
+        if (config.oneTime) {
+            if (!config.runAt) {
+                throw new Error('One-time schedules require a runAt date');
+            }
+            if (config.runAt <= new Date()) {
+                throw new Error('One-time schedule runAt must be in the future');
+            }
+            return;
+        }
+        if (!config.cronExpression) {
+            throw new Error('Recurring schedules require a cronExpression');
+        }
+        if (!cron.validate(config.cronExpression)) {
+            throw new Error('Invalid cron expression');
+        }
+    }
+    configureRuntimeForJob(job) {
+        // Clean existing runtime handles first (used when toggling/reloading)
+        if (job.task) {
+            job.task.stop();
+            job.task = undefined;
+        }
+        if (job.timeout) {
+            clearTimeout(job.timeout);
+            job.timeout = undefined;
+        }
+        const { config } = job;
+        if (config.oneTime && config.runAt) {
+            if (!config.active) {
+                return;
+            }
+            const delay = config.runAt.getTime() - Date.now();
+            if (delay <= 0) {
+                return;
+            }
+            job.timeout = setTimeout(async () => {
+                await this.executeJob(config.id);
+                this.removeSchedule(config.id);
+            }, delay);
+            return;
+        }
+        if (config.cronExpression) {
+            job.task = cron.schedule(config.cronExpression, async () => {
+                await this.executeJob(config.id);
+            }, {
+                timezone: this.timezone,
+            });
+            if (!config.active) {
+                job.task.stop();
+            }
+        }
+    }
+    toPersistedSchedule(config) {
+        return {
+            id: config.id,
+            cronExpression: config.cronExpression,
+            oneTime: config.oneTime,
+            runAt: config.runAt ? config.runAt.toISOString() : undefined,
+            message: config.message,
+            description: config.description,
+            createdAt: config.createdAt.toISOString(),
+            lastRun: config.lastRun ? config.lastRun.toISOString() : undefined,
+            active: config.active,
+        };
+    }
+    parsePersistedSchedule(config) {
+        return {
+            id: config.id,
+            cronExpression: config.cronExpression,
+            oneTime: config.oneTime,
+            runAt: config.runAt ? new Date(config.runAt) : undefined,
+            message: config.message,
+            description: config.description,
+            createdAt: new Date(config.createdAt),
+            lastRun: config.lastRun ? new Date(config.lastRun) : undefined,
+            active: config.active,
+        };
+    }
+    persistSchedules() {
+        if (!this.persistenceFilePath) {
+            return;
+        }
+        try {
+            fs.mkdirSync(path.dirname(this.persistenceFilePath), { recursive: true });
+            const schedules = Array.from(this.jobs.values()).map((job) => this.toPersistedSchedule(job.config));
+            fs.writeFileSync(this.persistenceFilePath, `${JSON.stringify({ schedules }, null, 2)}\n`, 'utf8');
+        }
+        catch (error) {
+            this.logInfo('Failed to persist schedules', {
+                persistenceFilePath: this.persistenceFilePath,
+                error: getErrorMessage(error),
+            });
+        }
+    }
+    loadPersistedSchedules() {
+        if (!this.persistenceFilePath) {
+            return;
+        }
+        try {
+            if (!fs.existsSync(this.persistenceFilePath)) {
+                return;
+            }
+            const raw = fs.readFileSync(this.persistenceFilePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            const schedules = Array.isArray(parsed?.schedules) ? parsed.schedules : [];
+            const now = new Date();
+            for (const persisted of schedules) {
+                const config = this.parsePersistedSchedule(persisted);
+                // Drop one-time schedules that are already past due on restart
+                if (config.oneTime && config.runAt && config.runAt <= now) {
+                    continue;
+                }
+                if (!config.oneTime && (!config.cronExpression || !cron.validate(config.cronExpression))) {
+                    this.logInfo('Skipping invalid persisted recurring schedule', { scheduleId: config.id });
+                    continue;
+                }
+                const job = { config };
+                this.configureRuntimeForJob(job);
+                this.jobs.set(config.id, job);
+            }
+            this.logInfo('Loaded persisted schedules', {
+                count: this.jobs.size,
+                persistenceFilePath: this.persistenceFilePath,
+            });
+            // Clean up persisted file if we dropped stale entries
+            this.persistSchedules();
+        }
+        catch (error) {
+            this.logInfo('Failed to load persisted schedules', {
+                persistenceFilePath: this.persistenceFilePath,
+                error: getErrorMessage(error),
+            });
+        }
+    }
+    /**
+     * Create a new schedule
+     */
+    createSchedule(config) {
+        const scheduleConfig = {
+            ...config,
+            id: this.generateId(),
+            createdAt: new Date(),
+            active: true,
+        };
+        this.validateScheduleConfig(scheduleConfig);
+        const job = {
+            config: scheduleConfig,
+        };
+        this.configureRuntimeForJob(job);
+        this.jobs.set(scheduleConfig.id, job);
+        this.persistSchedules();
+        return scheduleConfig;
+    }
+    /**
+     * Execute a scheduled job
+     */
+    async executeJob(scheduleId) {
+        const job = this.jobs.get(scheduleId);
+        if (!job || !job.config.active) {
+            return;
+        }
+        // Skip if job is already in flight (prevents overlapping executions)
+        if (job.inFlight) {
+            console.warn(`[CronScheduler] Job ${scheduleId} skipped - previous execution still in progress`);
+            return;
+        }
+        job.inFlight = true;
+        job.config.lastRun = new Date();
+        this.persistSchedules();
+        try {
+            await this.jobCallback(job.config);
+        }
+        catch (error) {
+            console.error(`[CronScheduler] Job ${scheduleId} execution failed: ${getErrorMessage(error)}`);
+        }
+        finally {
+            job.inFlight = false;
+        }
+    }
+    /**
+     * Get a schedule by ID
+     */
+    getSchedule(scheduleId) {
+        const job = this.jobs.get(scheduleId);
+        return job ? job.config : null;
+    }
+    /**
+     * List all schedules
+     */
+    listSchedules() {
+        return Array.from(this.jobs.values()).map(job => job.config);
+    }
+    /**
+     * Remove a schedule
+     */
+    removeSchedule(scheduleId) {
+        const job = this.jobs.get(scheduleId);
+        if (!job) {
+            return false;
+        }
+        // Stop the cron task if it exists
+        if (job.task) {
+            job.task.stop();
+        }
+        // Clear timeout if it exists (for one-time jobs)
+        if (job.timeout) {
+            clearTimeout(job.timeout);
+        }
+        this.jobs.delete(scheduleId);
+        this.persistSchedules();
+        return true;
+    }
+    /**
+     * Pause/resume a schedule
+     */
+    toggleSchedule(scheduleId, active) {
+        const job = this.jobs.get(scheduleId);
+        if (!job) {
+            return false;
+        }
+        job.config.active = active;
+        if (job.task) {
+            if (active) {
+                job.task.start();
+            }
+            else {
+                job.task.stop();
+            }
+        }
+        this.persistSchedules();
+        return true;
+    }
+    /**
+     * Generate a unique ID for a schedule
+     */
+    generateId() {
+        return `schedule_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Shutdown all scheduled jobs
+     */
+    shutdown() {
+        for (const [scheduleId] of this.jobs) {
+            this.removeSchedule(scheduleId);
+        }
+    }
+}

package/dist/scheduler/scheduledJobHandler.js

@@ -0,0 +1,34 @@
+import { getErrorMessage } from '../utils/error.js';
+export function createScheduledJobHandler(deps) {
+    const { logInfo, buildPromptWithMemory, runScheduledPromptWithTempAcp, resolveTargetChatId, sendTextToChat, normalizeOutgoingText, } = deps;
+    return async function handleScheduledJob(schedule) {
+        logInfo('Executing scheduled job', { scheduleId: schedule.id, message: schedule.message });
+        try {
+            const promptForGemini = buildPromptWithMemory(schedule.message);
+            logInfo('Scheduler prompt payload sent to Gemini', {
+                scheduleId: schedule.id,
+                prompt: promptForGemini,
+            });
+            const response = await runScheduledPromptWithTempAcp(promptForGemini, schedule.id);
+            const targetChatId = resolveTargetChatId();
+            if (targetChatId) {
+                await sendTextToChat(targetChatId, normalizeOutgoingText(response));
+                logInfo('Scheduled job result sent to Telegram', { scheduleId: schedule.id, chatId: targetChatId });
+            }
+            else {
+                logInfo('No target chat available for scheduled job result', { scheduleId: schedule.id });
+            }
+        }
+        catch (error) {
+            logInfo('Scheduled job execution failed', {
+                scheduleId: schedule.id,
+                error: getErrorMessage(error),
+            });
+            const targetChatId = resolveTargetChatId();
+            if (targetChatId) {
+                const errorMessage = `❌ Scheduled task failed: ${schedule.description || schedule.message}\n\nError: ${getErrorMessage(error)}`;
+                await sendTextToChat(targetChatId, normalizeOutgoingText(errorMessage));
+            }
+        }
+    };
+}

package/dist/utils/error.js

@@ -0,0 +1,12 @@
+export function getErrorMessage(error, fallback = 'Unknown error') {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error === null || error === undefined) {
+        return fallback;
+    }
+    return String(error);
+}

package/dist/utils/telegramMarkdown.js

@@ -0,0 +1,128 @@
+import { marked } from 'marked';
+function safeHref(href) {
+    const value = String(href || '').trim();
+    return /^https?:\/\//i.test(value) || /^mailto:/i.test(value) ? value : '';
+}
+function stripAnsiAndControl(text) {
+    return String(text || '')
+        .replace(/\u001b\[[0-9;]*m/g, '')
+        .replace(/\u001b\][^\u0007]*\u0007/g, '')
+        .replace(/\r/g, '')
+        .replace(/[\u200B-\u200D\uFEFF]/g, '');
+}
+function stripHtmlTags(text) {
+    return text.replace(/<[^>]+>/g, '');
+}
+function normalizeWhitespace(text) {
+    return String(text || '').replace(/\n{3,}/g, '\n\n').trim();
+}
+function simplifyHtmlForTelegram(markdown) {
+    let html = marked.parse(markdown, {
+        async: false,
+        gfm: true,
+        breaks: true,
+    });
+    html = html
+        .replace(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/gi, '<b>$1</b>\n\n')
+        .replace(/<p>([\s\S]*?)<\/p>/gi, '$1\n\n')
+        .replace(/<strong>([\s\S]*?)<\/strong>/gi, '<b>$1</b>')
+        .replace(/<em>([\s\S]*?)<\/em>/gi, '<i>$1</i>')
+        .replace(/<del>([\s\S]*?)<\/del>/gi, '<s>$1</s>')
+        .replace(/<li>([\s\S]*?)<\/li>/gi, '• $1\n')
+        .replace(/<\/?(ul|ol)>/gi, '')
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<hr\s*\/?>/gi, '────────\n\n')
+        .replace(/<pre><code[^>]*>/gi, '<pre><code>')
+        .replace(/<code[^>]*>/gi, '<code>');
+    html = html.replace(/<a\s+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_m, href, label) => {
+        const safe = safeHref(href);
+        return safe ? `<a href="${safe}">${label}</a>` : label;
+    });
+    const allowed = new Set(['b', 'i', 's', 'code', 'pre', 'a', 'blockquote']);
+    html = html.replace(/<\/?([a-z0-9]+)(\s[^>]*)?>/gi, (full, tag) => {
+        const name = String(tag || '').toLowerCase();
+        if (!allowed.has(name)) {
+            return '';
+        }
+        if (name === 'a') {
+            if (full.startsWith('</')) {
+                return '</a>';
+            }
+            const hrefMatch = full.match(/href="([^"]+)"/i);
+            const safe = safeHref(hrefMatch?.[1] || '');
+            return safe ? `<a href="${safe}">` : '';
+        }
+        return full.startsWith('</') ? `</${name}>` : `<${name}>`;
+    });
+    return normalizeWhitespace(html);
+}
+function splitPlainText(text, maxLength) {
+    const value = String(text || '');
+    if (!value) {
+        return [''];
+    }
+    if (value.length <= maxLength) {
+        return [value];
+    }
+    const chunks = [];
+    let start = 0;
+    while (start < value.length) {
+        const end = Math.min(start + maxLength, value.length);
+        chunks.push(value.slice(start, end));
+        start = end;
+    }
+    return chunks;
+}
+export function formatMarkdownForTelegram(markdown, maxMessageLength) {
+    const cleaned = stripAnsiAndControl(markdown);
+    const rendered = simplifyHtmlForTelegram(cleaned);
+    const sections = rendered
+        .split(/\n\n+/)
+        .map((section) => section.trim())
+        .filter(Boolean);
+    if (sections.length === 0) {
+        return {
+            chunks: ['No response received.'],
+            parseMode: 'HTML',
+        };
+    }
+    const chunks = [];
+    let current = '';
+    const appendCurrent = () => {
+        if (current.trim()) {
+            chunks.push(current.trim());
+            current = '';
+        }
+    };
+    for (const section of sections) {
+        const candidate = current ? `${current}\n\n${section}` : section;
+        if (candidate.length <= maxMessageLength) {
+            current = candidate;
+            continue;
+        }
+        appendCurrent();
+        if (section.length <= maxMessageLength) {
+            current = section;
+            continue;
+        }
+        const plainParts = splitPlainText(stripHtmlTags(section), maxMessageLength);
+        chunks.push(...plainParts);
+    }
+    appendCurrent();
+    return {
+        chunks: chunks.length > 0 ? chunks : ['No response received.'],
+        parseMode: 'HTML',
+    };
+}
+export function formatPreviewText(text, maxLength) {
+    const cleaned = normalizeWhitespace(stripAnsiAndControl(text));
+    if (!cleaned) {
+        return '';
+    }
+    const preview = cleaned.length <= maxLength ? cleaned : `${cleaned.slice(0, maxLength - 1)}…`;
+    return preview
+        .replace(/^#{1,6}\s+/gm, '')
+        .replace(/\*\*(.*?)\*\*/g, '$1')
+        .replace(/__(.*?)__/g, '$1')
+        .replace(/`([^`]+)`/g, '$1');
+}

package/ecosystem.config.json

@@ -0,0 +1,23 @@
+{
+  "apps": [
+    {
+      "name": "clawless",
+      "script": "clawless",
+      "interpreter": "none",
+      "instances": 1,
+      "exec_mode": "fork",
+      "watch": false,
+      "autorestart": true,
+      "max_restarts": 10,
+      "min_uptime": "10s",
+      "max_memory_restart": "500M",
+      "env": {
+        "NODE_ENV": "production"
+      },
+      "error_file": "./logs/err.log",
+      "out_file": "./logs/out.log",
+      "log_date_format": "YYYY-MM-DD HH:mm:ss Z",
+      "merge_logs": true
+    }
+  ]
+}