@grinev/opencode-telegram-bot 0.19.3 → 0.20.1

package/dist/scheduled-task/executor.js

@@ -2,6 +2,7 @@ import { config } from "../config.js";
 import { t } from "../i18n/index.js";
 import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
+import { cleanupScheduledTaskSessionIgnores, registerScheduledTaskSessionIgnore, } from "./session-ignore.js";
 export const SCHEDULED_TASK_AGENT = "build";
 const SCHEDULED_TASK_SESSION_TITLE = "Scheduled task run";
 const EXECUTION_POLL_INTERVAL_MS = 2000;
@@ -298,6 +299,7 @@ export async function executeScheduledTask(task) {
     let sessionId = null;
     let deleteTemporarySession = true;
     try {
+        await cleanupScheduledTaskSessionIgnores();
         const { data: session, error: createError } = await opencodeClient.session.create({
             directory: task.projectWorktree,
             title: SCHEDULED_TASK_SESSION_TITLE,
@@ -306,6 +308,7 @@ export async function executeScheduledTask(task) {
             throw createError || new Error("Failed to create temporary scheduled task session");
         }
         sessionId = session.id;
+        await registerScheduledTaskSessionIgnore(session.id);
         const promptOptions = {
             sessionID: session.id,
             directory: session.directory,

package/dist/scheduled-task/foreground-state.js

@@ -1,32 +1,42 @@
 import { logger } from "../utils/logger.js";
 class ForegroundSessionState {
-    activeSessionIds = new Set();
-    markBusy(sessionId) {
-        if (!sessionId) {
+    activeSessions = new Map();
+    markBusy(sessionId, directory) {
+        if (!sessionId || !directory) {
             return;
         }
-        this.activeSessionIds.add(sessionId);
-        logger.debug(`[ScheduledTaskForeground] Marked session busy: session=${sessionId}, count=${this.activeSessionIds.size}`);
+        this.activeSessions.set(sessionId, { sessionId, directory, markedAt: Date.now() });
+        logger.debug(`[ScheduledTaskForeground] Marked session busy: session=${sessionId}, directory=${directory}, count=${this.activeSessions.size}`);
     }
     markIdle(sessionId) {
         if (!sessionId) {
             return;
         }
-        this.activeSessionIds.delete(sessionId);
-        logger.debug(`[ScheduledTaskForeground] Marked session idle: session=${sessionId}, count=${this.activeSessionIds.size}`);
+        this.activeSessions.delete(sessionId);
+        logger.debug(`[ScheduledTaskForeground] Marked session idle: session=${sessionId}, count=${this.activeSessions.size}`);
+    }
+    getBusySessions() {
+        return Array.from(this.activeSessions.values(), (session) => ({ ...session }));
     }
     isBusy() {
-        return this.activeSessionIds.size > 0;
+        return this.activeSessions.size > 0;
     }
     clearAll(reason) {
-        if (this.activeSessionIds.size === 0) {
+        if (this.activeSessions.size === 0) {
             return;
         }
-        logger.info(`[ScheduledTaskForeground] Cleared foreground busy state: reason=${reason}, count=${this.activeSessionIds.size}`);
-        this.activeSessionIds.clear();
+        logger.info(`[ScheduledTaskForeground] Cleared foreground busy state: reason=${reason}, count=${this.activeSessions.size}`);
+        this.activeSessions.clear();
     }
     __resetForTests() {
-        this.activeSessionIds.clear();
+        this.activeSessions.clear();
+    }
+    __setMarkedAtForTests(sessionId, markedAt) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        this.activeSessions.set(sessionId, { ...session, markedAt });
     }
 }
 export const foregroundSessionState = new ForegroundSessionState();

package/dist/scheduled-task/runtime.js

@@ -7,6 +7,7 @@ import { sendBotText } from "../bot/utils/telegram-text.js";
 import { formatAssistantRunFooter } from "../bot/utils/assistant-run-footer.js";
 import { executeScheduledTask, SCHEDULED_TASK_AGENT } from "./executor.js";
 import { foregroundSessionState } from "./foreground-state.js";
+import { cleanupScheduledTaskSessionIgnores } from "./session-ignore.js";
 import { computeNextRunAt, isTaskDue } from "./next-run.js";
 import { getScheduledTask, listScheduledTasks, removeScheduledTask, replaceScheduledTasks, updateScheduledTask, } from "./store.js";
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
@@ -96,6 +97,7 @@ export class ScheduledTaskRuntime {
             return;
         }
         this.initialized = true;
+        await cleanupScheduledTaskSessionIgnores();
         await this.recoverTasksOnStartup();
         await this.flushDeferredDeliveries();
     }

package/dist/scheduled-task/schedule-parser.js

@@ -1,5 +1,6 @@
 import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
+import { cleanupScheduledTaskSessionIgnores, registerScheduledTaskSessionIgnore, } from "./session-ignore.js";
 const SCHEDULE_PARSE_SESSION_TITLE = "Scheduled task schedule parser";
 function getLocalTimezone() {
     return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
@@ -133,6 +134,8 @@ export async function parseTaskSchedule(scheduleText, directory) {
     const timezone = getLocalTimezone();
     let sessionId = null;
     try {
+        logger.debug(`[ScheduledTaskScheduleParser] Parsing schedule: directory=${trimmedDirectory}, textLength=${trimmedScheduleText.length}`);
+        await cleanupScheduledTaskSessionIgnores();
         const { data: session, error: createError } = await opencodeClient.session.create({
             directory: trimmedDirectory,
             title: SCHEDULE_PARSE_SESSION_TITLE,
@@ -141,6 +144,8 @@ export async function parseTaskSchedule(scheduleText, directory) {
             throw createError || new Error("Failed to create temporary schedule parser session");
         }
         sessionId = session.id;
+        await registerScheduledTaskSessionIgnore(session.id);
+        logger.debug(`[ScheduledTaskScheduleParser] Created temporary session: sessionId=${session.id}`);
         const { data: response, error: promptError } = await opencodeClient.session.prompt({
             sessionID: session.id,
             directory: session.directory,
@@ -151,6 +156,7 @@ export async function parseTaskSchedule(scheduleText, directory) {
             throw promptError || new Error("Failed to parse schedule");
         }
         const responseText = collectResponseText(response.parts);
+        logger.debug(`[ScheduledTaskScheduleParser] Received parser response: sessionId=${session.id}, textLength=${responseText.length}`);
         if (!responseText) {
             throw new Error("Schedule parser returned an empty response");
         }

package/dist/scheduled-task/session-ignore.js

@@ -0,0 +1,53 @@
+import { getScheduledTaskSessionIgnores, setScheduledTaskSessionIgnores, } from "../settings/manager.js";
+const SCHEDULED_TASK_SESSION_IGNORE_TTL_MS = 24 * 60 * 60 * 1000;
+let mutationQueue = Promise.resolve();
+function isFreshIgnore(ignore, nowMs) {
+    const createdAtMs = Date.parse(ignore.createdAt);
+    return !Number.isNaN(createdAtMs) && nowMs - createdAtMs < SCHEDULED_TASK_SESSION_IGNORE_TTL_MS;
+}
+function pruneExpiredIgnores(ignores, nowMs) {
+    return ignores.filter((ignore) => isFreshIgnore(ignore, nowMs));
+}
+async function mutateIgnores(mutator) {
+    const runMutation = async () => {
+        const currentIgnores = getScheduledTaskSessionIgnores();
+        const { ignores, result } = mutator(currentIgnores);
+        await setScheduledTaskSessionIgnores(ignores);
+        return result;
+    };
+    const mutationPromise = mutationQueue.then(runMutation, runMutation);
+    mutationQueue = mutationPromise.catch(() => undefined);
+    return mutationPromise;
+}
+export function isScheduledTaskSessionIgnored(sessionId, now = new Date()) {
+    const nowMs = now.getTime();
+    return getScheduledTaskSessionIgnores().some((ignore) => ignore.sessionId === sessionId && isFreshIgnore(ignore, nowMs));
+}
+export async function registerScheduledTaskSessionIgnore(sessionId, createdAt = new Date()) {
+    await mutateIgnores((ignores) => {
+        const nowMs = createdAt.getTime();
+        const nextIgnores = pruneExpiredIgnores(ignores, nowMs).filter((ignore) => ignore.sessionId !== sessionId);
+        return {
+            ignores: [...nextIgnores, { sessionId, createdAt: createdAt.toISOString() }],
+            result: undefined,
+        };
+    });
+}
+export async function removeScheduledTaskSessionIgnore(sessionId) {
+    await mutateIgnores((ignores) => ({
+        ignores: ignores.filter((ignore) => ignore.sessionId !== sessionId),
+        result: undefined,
+    }));
+}
+export async function cleanupScheduledTaskSessionIgnores(now = new Date()) {
+    return mutateIgnores((ignores) => {
+        const nextIgnores = pruneExpiredIgnores(ignores, now.getTime());
+        return {
+            ignores: nextIgnores,
+            result: ignores.length - nextIgnores.length,
+        };
+    });
+}
+export function __resetScheduledTaskSessionIgnoreForTests() {
+    mutationQueue = Promise.resolve();
+}

package/dist/settings/manager.js

@@ -5,6 +5,9 @@ import { logger } from "../utils/logger.js";
 function cloneScheduledTasks(tasks) {
     return tasks?.map((task) => cloneScheduledTask(task));
 }
+function cloneScheduledTaskSessionIgnores(ignores) {
+    return ignores?.map((ignore) => ({ ...ignore }));
+}
 function getSettingsFilePath() {
     return getRuntimePaths().settingsFilePath;
 }
@@ -121,6 +124,13 @@ export function setScheduledTasks(tasks) {
     currentSettings.scheduledTasks = cloneScheduledTasks(tasks);
     return writeSettingsFile(currentSettings);
 }
+export function getScheduledTaskSessionIgnores() {
+    return cloneScheduledTaskSessionIgnores(currentSettings.scheduledTaskSessionIgnores) ?? [];
+}
+export function setScheduledTaskSessionIgnores(ignores) {
+    currentSettings.scheduledTaskSessionIgnores = cloneScheduledTaskSessionIgnores(ignores);
+    return writeSettingsFile(currentSettings);
+}
 export function __resetSettingsForTests() {
     currentSettings = {};
     settingsWriteQueue = Promise.resolve();
@@ -138,6 +148,8 @@ export async function loadSettings() {
     }
     currentSettings = loadedSettings;
     currentSettings.scheduledTasks = cloneScheduledTasks(loadedSettings.scheduledTasks) ?? [];
+    currentSettings.scheduledTaskSessionIgnores =
+        cloneScheduledTaskSessionIgnores(loadedSettings.scheduledTaskSessionIgnores) ?? [];
     if (requiresRewrite) {
         void writeSettingsFile(currentSettings);
     }

package/dist/summary/aggregator.js

@@ -173,6 +173,10 @@ class SummaryAggregator {
             this.handleMessagePartDelta(event);
             return;
         }
+        if (eventType === "server.heartbeat") {
+            logger.debug("[Aggregator] Heartbeat received");
+            return;
+        }
         // Log all question-related events for debugging
         if (event.type.startsWith("question.")) {
             logger.info(`[Aggregator] Question event: ${event.type}`, JSON.stringify(event.properties, null, 2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.19.3",
+  "version": "0.20.1",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",