@grinev/opencode-telegram-bot 0.16.0 → 0.17.0

package/dist/pinned/manager.js

@@ -1,7 +1,6 @@
-import { readFile, stat } from "node:fs/promises";
-import path from "node:path";
 import { logger } from "../utils/logger.js";
 import { opencodeClient } from "../opencode/client.js";
+import { getGitWorktreeContext } from "../git/worktree.js";
 import { getCurrentSession } from "../session/manager.js";
 import { getCurrentProject, getPinnedMessageId, setPinnedMessageId, clearPinnedMessageId, } from "../settings/manager.js";
 import { getStoredModel } from "../model/manager.js";
@@ -16,8 +15,9 @@ class PinnedMessageManager {
         chatId: null,
         sessionId: null,
         sessionTitle: t("pinned.default_session_title"),
-        projectName: "",
+        projectPath: "",
         projectBranch: null,
+        projectWorktreePath: null,
         tokensUsed: 0,
         tokensLimit: 0,
         lastUpdated: 0,
@@ -419,66 +419,27 @@ class PinnedMessageManager {
      */
     async refreshProjectMetadata() {
         const project = getCurrentProject();
-        this.state.projectName =
-            project?.name || this.extractProjectName(project?.worktree) || t("pinned.unknown");
-        this.state.projectBranch = await this.getGitBranchName(project?.worktree);
-    }
-    /**
-     * Resolve current git branch for a project worktree.
-     */
-    async getGitBranchName(worktree) {
-        if (!worktree) {
-            return null;
+        this.state.projectPath = project?.worktree || t("pinned.unknown");
+        this.state.projectBranch = null;
+        this.state.projectWorktreePath = null;
+        if (!project?.worktree) {
+            return;
         }
         try {
-            const gitDir = await this.resolveGitDir(worktree);
-            if (!gitDir) {
-                return null;
+            const worktreeContext = await getGitWorktreeContext(project.worktree);
+            if (!worktreeContext) {
+                return;
             }
-            const headPath = path.join(gitDir, "HEAD");
-            const headContent = (await readFile(headPath, "utf-8")).trim();
-            const match = headContent.match(/^ref:\s+refs\/heads\/(.+)$/);
-            return match?.[1] || null;
+            this.state.projectPath = worktreeContext.mainProjectPath;
+            this.state.projectBranch = worktreeContext.branch;
+            this.state.projectWorktreePath = worktreeContext.isLinkedWorktree
+                ? worktreeContext.activeWorktreePath
+                : null;
         }
         catch (err) {
-            logger.debug("[PinnedManager] Could not resolve git branch:", err);
-            return null;
+            logger.debug("[PinnedManager] Could not resolve git worktree metadata:", err);
         }
     }
-    /**
-     * Resolve git directory for a normal repository or linked worktree.
-     */
-    async resolveGitDir(worktree) {
-        const gitPath = path.join(worktree, ".git");
-        try {
-            const gitStat = await stat(gitPath);
-            if (gitStat.isDirectory()) {
-                return gitPath;
-            }
-            if (!gitStat.isFile()) {
-                return null;
-            }
-            const gitPointer = (await readFile(gitPath, "utf-8")).trim();
-            const match = gitPointer.match(/^gitdir:\s*(.+)$/i);
-            if (!match) {
-                return null;
-            }
-            return path.resolve(worktree, match[1].trim());
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Extract project name from worktree path
-     */
-    extractProjectName(worktree) {
-        if (!worktree)
-            return "";
-        // Get last part of path
-        const parts = worktree.replace(/\\/g, "/").split("/");
-        return parts[parts.length - 1] || "";
-    }
     /**
      * Make file path relative to project worktree
      */
@@ -540,14 +501,17 @@ class PinnedMessageManager {
         const currentModel = getStoredModel();
         const modelName = formatModelDisplayName(currentModel.providerID, currentModel.modelID);
         const projectDisplayName = this.state.projectBranch
-            ? `${this.state.projectName}: ${this.state.projectBranch}`
-            : this.state.projectName;
+            ? `${this.state.projectPath}: ${this.state.projectBranch}`
+            : this.state.projectPath;
         const lines = [
             `${this.state.sessionTitle}`,
             t("pinned.line.project", { project: projectDisplayName }),
-            t("pinned.line.model", { model: modelName }),
-            formatContextLine(this.state.tokensUsed, this.state.tokensLimit),
         ];
+        if (this.state.projectWorktreePath) {
+            lines.push(t("pinned.line.worktree", { worktree: this.state.projectWorktreePath }));
+        }
+        lines.push(t("pinned.line.model", { model: modelName }));
+        lines.push(formatContextLine(this.state.tokensUsed, this.state.tokensLimit));
         if (this.state.cost !== undefined && this.state.cost !== null) {
             lines.push(formatCostLine(this.state.cost));
         }
@@ -710,7 +674,9 @@ class PinnedMessageManager {
             this.state.sessionId = null;
             this.state.tokensUsed = 0;
             this.state.tokensLimit = 0;
+            this.state.projectPath = "";
             this.state.projectBranch = null;
+            this.state.projectWorktreePath = null;
             this.state.changedFiles = [];
             this.lastRenderedMessageText = null;
             this.pendingUpdate = false;
@@ -725,8 +691,9 @@ class PinnedMessageManager {
             this.state.messageId = null;
             this.state.sessionId = null;
             this.state.sessionTitle = t("pinned.default_session_title");
-            this.state.projectName = "";
+            this.state.projectPath = "";
             this.state.projectBranch = null;
+            this.state.projectWorktreePath = null;
             this.state.tokensUsed = 0;
             this.state.tokensLimit = 0;
             this.state.changedFiles = [];

package/dist/project/manager.js

@@ -3,35 +3,8 @@ import path from "node:path";
 import { opencodeClient } from "../opencode/client.js";
 import { getCachedSessionProjects } from "../session/cache-manager.js";
 import { logger } from "../utils/logger.js";
-async function isLinkedGitWorktree(worktree) {
-    if (worktree === "/") {
-        return false;
-    }
-    const gitPath = path.join(worktree, ".git");
-    try {
-        const gitStat = await stat(gitPath);
-        if (!gitStat.isFile()) {
-            return false;
-        }
-        const gitPointer = (await readFile(gitPath, "utf-8")).trim();
-        const match = gitPointer.match(/^gitdir:\s*(.+)$/i);
-        if (!match) {
-            return false;
-        }
-        const gitDir = path.resolve(worktree, match[1].trim()).replace(/\\/g, "/").toLowerCase();
-        return gitDir.includes("/.git/worktrees/");
-    }
-    catch {
-        return false;
-    }
-}
-function worktreeKey(worktree) {
-    if (process.platform === "win32") {
-        return worktree.toLowerCase();
-    }
-    return worktree;
-}
-export async function getProjects() {
+async function getResolvedProjects(options) {
+    const includeLinkedWorktrees = options?.includeLinkedWorktrees === true;
     const { data: projects, error } = await opencodeClient.project.list();
     if (error || !projects) {
         throw error || new Error("No data received from server");
@@ -64,11 +37,53 @@ export async function getProjects() {
         });
     }
     const projectList = Array.from(mergedByWorktree.values()).sort((left, right) => right.lastUpdated - left.lastUpdated);
+    if (includeLinkedWorktrees) {
+        return projectList;
+    }
     const linkedWorktreeFlags = await Promise.all(projectList.map((project) => isLinkedGitWorktree(project.worktree)));
     const visibleProjects = projectList.filter((_, index) => !linkedWorktreeFlags[index]);
     const hiddenLinkedWorktrees = projectList.length - visibleProjects.length;
     logger.debug(`[ProjectManager] Projects resolved: api=${projects.length}, cached=${cachedProjects.length}, hiddenLinkedWorktrees=${hiddenLinkedWorktrees}, total=${visibleProjects.length}`);
-    return visibleProjects.map(({ id, worktree, name }) => ({ id, worktree, name }));
+    return visibleProjects;
+}
+async function isLinkedGitWorktree(worktree) {
+    if (worktree === "/") {
+        return false;
+    }
+    const gitPath = path.join(worktree, ".git");
+    try {
+        const gitStat = await stat(gitPath);
+        if (!gitStat.isFile()) {
+            return false;
+        }
+        const gitPointer = (await readFile(gitPath, "utf-8")).trim();
+        const match = gitPointer.match(/^gitdir:\s*(.+)$/i);
+        if (!match) {
+            return false;
+        }
+        const gitDir = path.resolve(worktree, match[1].trim()).replace(/\\/g, "/").toLowerCase();
+        return gitDir.includes("/.git/worktrees/");
+    }
+    catch {
+        return false;
+    }
+}
+function worktreeKey(worktree) {
+    const pathModule = isWindowsWorktreePath(worktree) ? path.win32 : path.posix;
+    const normalizedWorktree = pathModule.normalize(worktree);
+    const root = pathModule.parse(normalizedWorktree).root;
+    const trimmedWorktree = normalizedWorktree === root ? normalizedWorktree : normalizedWorktree.replace(/[\\/]+$/, "");
+    if (pathModule === path.win32) {
+        return trimmedWorktree.toLowerCase();
+    }
+    return trimmedWorktree;
+}
+function isWindowsWorktreePath(worktree) {
+    return process.platform === "win32" || /^[a-zA-Z]:[\\/]/.test(worktree) || /^\\\\/.test(worktree);
+}
+export async function getProjects() {
+    const projects = await getResolvedProjects();
+    return projects.map(({ id, worktree, name }) => ({ id, worktree, name }));
 }
 export async function getProjectById(id) {
     const projects = await getProjects();
@@ -79,11 +94,11 @@ export async function getProjectById(id) {
     return project;
 }
 export async function getProjectByWorktree(worktree) {
-    const projects = await getProjects();
+    const projects = await getResolvedProjects({ includeLinkedWorktrees: true });
     const key = worktreeKey(worktree);
     const project = projects.find((p) => worktreeKey(p.worktree) === key);
     if (!project) {
         throw new Error(`Project with worktree ${worktree} not found`);
     }
-    return project;
+    return { id: project.id, worktree: project.worktree, name: project.name };
 }

package/dist/runtime/bootstrap.js

@@ -10,6 +10,16 @@ const DEFAULT_API_URL = "http://localhost:4096";
 const DEFAULT_SERVER_USERNAME = "opencode";
 const FALLBACK_MODEL_PROVIDER = "opencode";
 const FALLBACK_MODEL_ID = "big-pickle";
+const WIZARD_ENV_KEYS = [
+    "BOT_LOCALE",
+    "TELEGRAM_BOT_TOKEN",
+    "TELEGRAM_ALLOWED_USER_ID",
+    "OPENCODE_API_URL",
+    "OPENCODE_SERVER_USERNAME",
+    "OPENCODE_SERVER_PASSWORD",
+    "OPENCODE_MODEL_PROVIDER",
+    "OPENCODE_MODEL_ID",
+];
 function isPositiveInteger(value) {
     return /^[1-9]\d*$/.test(value);
 }
@@ -55,10 +65,63 @@ function removeEnvKey(lines, key) {
     const regex = new RegExp(`^\\s*(?:export\\s+)?${escapeRegex(key)}\\s*=`);
     return lines.filter((line) => !regex.test(line));
 }
+function parseEnvAssignmentLine(line) {
+    const match = /^(\s*#\s*)?(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/.exec(line);
+    if (!match) {
+        return null;
+    }
+    return {
+        key: match[2],
+        rawValue: match[3],
+        line,
+        isCommented: typeof match[1] === "string",
+    };
+}
+function buildTemplateKeySet(templateContent) {
+    const keys = new Set();
+    for (const line of normalizeEnvLineEndings(templateContent)) {
+        const parsedLine = parseEnvAssignmentLine(line);
+        if (parsedLine !== null) {
+            keys.add(parsedLine.key);
+        }
+    }
+    return keys;
+}
+function collectActiveEnvAssignments(content) {
+    const assignments = new Map();
+    for (const line of normalizeEnvLineEndings(content)) {
+        const parsedLine = parseEnvAssignmentLine(line);
+        if (parsedLine === null || parsedLine.isCommented) {
+            continue;
+        }
+        assignments.set(parsedLine.key, parsedLine);
+    }
+    return assignments;
+}
+function collectCustomEnvAssignments(existingContent, templateKeys) {
+    const customAssignments = [];
+    const seenKeys = new Set();
+    const lines = normalizeEnvLineEndings(existingContent);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const parsedLine = parseEnvAssignmentLine(lines[index]);
+        if (parsedLine === null || parsedLine.isCommented || templateKeys.has(parsedLine.key)) {
+            continue;
+        }
+        if (seenKeys.has(parsedLine.key)) {
+            continue;
+        }
+        seenKeys.add(parsedLine.key);
+        customAssignments.push(parsedLine);
+    }
+    return customAssignments.reverse().map((assignment) => assignment.line);
+}
+function renderEnvAssignment(key, rawValue) {
+    return `${key}=${rawValue}`;
+}
 function finalizeEnvContent(lines) {
     return `${lines.join("\n")}\n`;
 }
-export function buildEnvFileContent(existingContent, values) {
+function buildFlatEnvFileContent(existingContent, values) {
     let lines = normalizeEnvLineEndings(existingContent);
     const orderedUpdates = [
         ["BOT_LOCALE", values.BOT_LOCALE],
@@ -78,6 +141,44 @@ export function buildEnvFileContent(existingContent, values) {
     }
     return finalizeEnvContent(lines);
 }
+export function buildEnvFileContent(existingContent, values, envExampleContent) {
+    if (!envExampleContent) {
+        return buildFlatEnvFileContent(existingContent, values);
+    }
+    const templateLines = normalizeEnvLineEndings(envExampleContent);
+    if (templateLines.length === 0) {
+        return buildFlatEnvFileContent(existingContent, values);
+    }
+    const templateKeys = buildTemplateKeySet(envExampleContent);
+    const existingAssignments = collectActiveEnvAssignments(existingContent);
+    const wizardOverrides = new Map(WIZARD_ENV_KEYS.map((key) => [key, values[key]]));
+    const renderedLines = templateLines.map((line) => {
+        const parsedLine = parseEnvAssignmentLine(line);
+        if (parsedLine === null) {
+            return line;
+        }
+        if (wizardOverrides.has(parsedLine.key)) {
+            const overrideValue = wizardOverrides.get(parsedLine.key);
+            if (overrideValue && overrideValue.trim().length > 0) {
+                return renderEnvAssignment(parsedLine.key, overrideValue);
+            }
+            return line;
+        }
+        const existingAssignment = existingAssignments.get(parsedLine.key);
+        if (existingAssignment !== undefined) {
+            return renderEnvAssignment(parsedLine.key, existingAssignment.rawValue);
+        }
+        return line;
+    });
+    const customAssignments = collectCustomEnvAssignments(existingContent, templateKeys);
+    if (customAssignments.length > 0) {
+        if (renderedLines.length > 0 && renderedLines[renderedLines.length - 1] !== "") {
+            renderedLines.push("");
+        }
+        renderedLines.push(...customAssignments);
+    }
+    return finalizeEnvContent(renderedLines);
+}
 async function readEnvFileIfExists(filePath) {
     try {
         return await fs.readFile(filePath, "utf-8");
@@ -112,14 +213,24 @@ function getEnvExamplePath() {
     const currentFilePath = fileURLToPath(import.meta.url);
     return path.resolve(path.dirname(currentFilePath), "..", "..", ".env.example");
 }
-async function loadModelDefaultsFromEnvExample() {
+async function loadEnvExampleContent() {
+    try {
+        return await fs.readFile(getEnvExamplePath(), "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function loadModelDefaultsFromEnvExample(envExampleContent) {
     const fallbackDefaults = {
         provider: FALLBACK_MODEL_PROVIDER,
         modelId: FALLBACK_MODEL_ID,
     };
     try {
-        const content = await fs.readFile(getEnvExamplePath(), "utf-8");
-        const parsed = dotenv.parse(content);
+        if (!envExampleContent) {
+            return fallbackDefaults;
+        }
+        const parsed = dotenv.parse(envExampleContent);
         const provider = parsed.OPENCODE_MODEL_PROVIDER?.trim();
         const modelId = parsed.OPENCODE_MODEL_ID?.trim();
         if (!provider || !modelId) {
@@ -305,11 +416,12 @@ async function validateExistingEnv(envFilePath) {
 }
 async function runWizardAndPersist(runtimePaths) {
     ensureInteractiveTty();
-    const [existingContent, modelDefaults, wizardValues] = await Promise.all([
+    const [existingContent, envExampleContent, wizardValues] = await Promise.all([
         readEnvFileIfExists(runtimePaths.envFilePath),
-        loadModelDefaultsFromEnvExample(),
+        loadEnvExampleContent(),
         collectWizardValues(),
     ]);
+    const modelDefaults = loadModelDefaultsFromEnvExample(envExampleContent);
     const existingParsed = existingContent ? dotenv.parse(existingContent) : {};
     const provider = existingParsed.OPENCODE_MODEL_PROVIDER || modelDefaults.provider;
     const modelId = existingParsed.OPENCODE_MODEL_ID || modelDefaults.modelId;
@@ -323,7 +435,7 @@ async function runWizardAndPersist(runtimePaths) {
         OPENCODE_MODEL_PROVIDER: provider,
         OPENCODE_MODEL_ID: modelId,
     };
-    const envContent = buildEnvFileContent(existingContent ?? "", envValues);
+    const envContent = buildEnvFileContent(existingContent ?? "", envValues, envExampleContent);
     await writeFileAtomically(runtimePaths.envFilePath, envContent);
     await ensureSettingsFile(runtimePaths.settingsFilePath);
     process.stdout.write(t("runtime.wizard.saved", {

package/dist/scheduled-task/executor.js

@@ -1,7 +1,12 @@
+import { config } from "../config.js";
 import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
 const SCHEDULED_TASK_AGENT = "build";
 const SCHEDULED_TASK_SESSION_TITLE = "Scheduled task run";
+const EXECUTION_POLL_INTERVAL_MS = 2000;
+const MAX_IDLE_POLLS_WITHOUT_RESULT = 3;
+const MODELS_DOCS_URL = "https://opencode.ai/docs/config/#models";
+const EXECUTION_TIMEOUT_ERROR_PREFIX = "Scheduled task exceeded bot execution timeout";
 function collectResponseText(parts) {
     return parts
         .filter((part) => part.type === "text" && typeof part.text === "string" && !part.ignored)
@@ -9,15 +14,143 @@ function collectResponseText(parts) {
         .join("")
         .trim();
 }
-function toErrorMessage(error) {
+function extractErrorMessage(error) {
     if (error instanceof Error && error.message.trim()) {
         return error.message.trim();
     }
     if (typeof error === "string" && error.trim()) {
         return error.trim();
     }
+    if (!error || typeof error !== "object") {
+        return null;
+    }
+    const typedError = error;
+    if (typeof typedError.data?.message === "string" && typedError.data.message.trim()) {
+        return typedError.data.message.trim();
+    }
+    if (typeof typedError.message === "string" && typedError.message.trim()) {
+        return typedError.message.trim();
+    }
+    if (typeof typedError.name === "string" && typedError.name.trim()) {
+        return typedError.name.trim();
+    }
+    return null;
+}
+function isTimeoutErrorMessage(message) {
+    return /(timed out|timeout|time out|deadline exceeded|request aborted)/i.test(message);
+}
+function isBotExecutionTimeoutMessage(message) {
+    return message.startsWith(EXECUTION_TIMEOUT_ERROR_PREFIX);
+}
+function createExecutionTimeoutMessage() {
+    return `${EXECUTION_TIMEOUT_ERROR_PREFIX} after ${config.bot.scheduledTaskExecutionTimeoutMinutes} minutes.`;
+}
+function getExecutionTimeoutMs() {
+    return config.bot.scheduledTaskExecutionTimeoutMinutes * 60 * 1000;
+}
+function normalizeScheduledTaskErrorMessage(message) {
+    if (isBotExecutionTimeoutMessage(message) ||
+        !isTimeoutErrorMessage(message) ||
+        message.includes(MODELS_DOCS_URL)) {
+        return message;
+    }
+    return `${message} Check OpenCode model timeout settings: ${MODELS_DOCS_URL}`;
+}
+function toErrorMessage(error) {
+    const message = extractErrorMessage(error);
+    if (message) {
+        return normalizeScheduledTaskErrorMessage(message);
+    }
     return "Unknown scheduled task execution error";
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function findLatestAssistantMessage(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.info.role === "assistant") {
+            return message;
+        }
+    }
+    return null;
+}
+function extractAssistantResult(message) {
+    if (!message) {
+        return { resultText: null, errorMessage: null, completed: false };
+    }
+    const errorMessage = extractErrorMessage(message.info.error);
+    if (errorMessage) {
+        return {
+            resultText: null,
+            errorMessage: normalizeScheduledTaskErrorMessage(errorMessage),
+            completed: true,
+        };
+    }
+    const resultText = collectResponseText(message.parts);
+    return {
+        resultText,
+        errorMessage: null,
+        completed: Boolean(message.info.time?.completed),
+    };
+}
+async function loadAssistantResult(sessionId, directory) {
+    const { data: messages, error: messagesError } = await opencodeClient.session.messages({
+        sessionID: sessionId,
+        directory,
+    });
+    if (messagesError || !messages) {
+        throw messagesError || new Error("Failed to load scheduled task messages");
+    }
+    return extractAssistantResult(findLatestAssistantMessage(messages));
+}
+async function waitForScheduledTaskResult(sessionId, directory) {
+    const startedAtMs = Date.now();
+    const executionTimeoutMs = getExecutionTimeoutMs();
+    let idlePollsWithoutResult = 0;
+    while (true) {
+        if (Date.now() - startedAtMs >= executionTimeoutMs) {
+            throw new Error(createExecutionTimeoutMessage());
+        }
+        const assistantResult = await loadAssistantResult(sessionId, directory);
+        if (assistantResult.errorMessage) {
+            throw new Error(assistantResult.errorMessage);
+        }
+        if (assistantResult.completed) {
+            if (assistantResult.resultText) {
+                return assistantResult.resultText;
+            }
+            throw new Error("Scheduled task returned an empty assistant response");
+        }
+        const { data: statuses, error: statusError } = await opencodeClient.session.status({
+            directory,
+        });
+        if (statusError || !statuses) {
+            throw statusError || new Error("Failed to load scheduled task status");
+        }
+        const sessionStatus = statuses[sessionId];
+        if (!sessionStatus || sessionStatus.type === "idle") {
+            const confirmedAssistantResult = await loadAssistantResult(sessionId, directory);
+            if (confirmedAssistantResult.errorMessage) {
+                throw new Error(confirmedAssistantResult.errorMessage);
+            }
+            if (confirmedAssistantResult.completed) {
+                if (confirmedAssistantResult.resultText) {
+                    return confirmedAssistantResult.resultText;
+                }
+                throw new Error("Scheduled task returned an empty assistant response");
+            }
+            idlePollsWithoutResult += 1;
+            if (idlePollsWithoutResult >= MAX_IDLE_POLLS_WITHOUT_RESULT) {
+                throw new Error("Scheduled task finished without a completed assistant response");
+            }
+        }
+        else {
+            idlePollsWithoutResult = 0;
+        }
+        await sleep(EXECUTION_POLL_INTERVAL_MS);
+    }
+}
 export async function executeScheduledTask(task) {
     const startedAt = new Date().toISOString();
     let sessionId = null;
@@ -45,14 +178,11 @@ export async function executeScheduledTask(task) {
         if (task.model.variant) {
             promptOptions.variant = task.model.variant;
         }
-        const { data: response, error: promptError } = await opencodeClient.session.prompt(promptOptions);
-        if (promptError || !response) {
+        const { error: promptError } = await opencodeClient.session.promptAsync(promptOptions);
+        if (promptError) {
             throw promptError || new Error("Scheduled task prompt execution failed");
         }
-        const resultText = collectResponseText(response.parts);
-        if (!resultText) {
-            throw new Error("Scheduled task returned an empty assistant response");
-        }
+        const resultText = await waitForScheduledTaskResult(session.id, session.directory);
         return {
             taskId: task.id,
             status: "success",

package/dist/scheduled-task/runtime.js

@@ -122,6 +122,14 @@ export class ScheduledTaskRuntime {
             this.flushInProgress = false;
         }
     }
+    shutdown() {
+        for (const timer of this.timersByTaskId.values()) {
+            clearTimeout(timer);
+        }
+        this.timersByTaskId.clear();
+        this.runningTaskIds.clear();
+        this.initialized = false;
+    }
     __resetForTests() {
         for (const timer of this.timersByTaskId.values()) {
             clearTimeout(timer);