mob-coordinator 0.2.1

package/dist/server/server/instance-manager.js

@@ -0,0 +1,434 @@
+import { EventEmitter } from 'events';
+import { generateInstanceId } from './util/id.js';
+import { HOOK_SILENCE_THRESHOLD_MS } from '../shared/constants.js';
+import { getGitBranch } from './util/platform.js';
+import { fetchJiraStatus } from './jira-client.js';
+import { detectStateFromTerminal } from './terminal-state-detector.js';
+import { createLogger } from './util/logger.js';
+const logger = createLogger('instance-mgr');
+const JIRA_KEY_RE = /([A-Z][A-Z0-9]+-\d+)/;
+function extractJiraKey(branch) {
+    if (!branch)
+        return null;
+    const m = branch.match(JIRA_KEY_RE);
+    return m ? m[1] : null;
+}
+export class InstanceManager extends EventEmitter {
+    log = logger;
+    instances = new Map();
+    managedIds = new Set();
+    autoNameIds = new Set();
+    promptCount = new Map();
+    ptyManager;
+    discovery;
+    sessionStore;
+    scrollbackBuffer;
+    settingsManager;
+    staleTimer = null;
+    jiraStatusCache = new Map();
+    subscribers = new Map();
+    constructor(ptyManager, discovery, sessionStore, scrollbackBuffer, settingsManager) {
+        super();
+        this.ptyManager = ptyManager;
+        this.discovery = discovery;
+        this.sessionStore = sessionStore;
+        this.scrollbackBuffer = scrollbackBuffer;
+        this.settingsManager = settingsManager;
+        this.setupListeners();
+        this.loadPreviousSessions();
+    }
+    loadPreviousSessions() {
+        const sessions = this.sessionStore.loadAll();
+        const toResume = [];
+        for (const info of sessions) {
+            this.instances.set(info.id, info);
+            this.managedIds.add(info.id);
+            if (info.autoResume) {
+                toResume.push(info);
+            }
+        }
+        // Auto-resume instances that were running when the server shut down
+        if (toResume.length > 0) {
+            // Defer so the server finishes initializing first
+            setTimeout(() => {
+                for (const info of toResume) {
+                    console.log(`[auto-resume] Resuming instance ${info.id} (${info.name}) in ${info.cwd}`);
+                    this.resume(info.id);
+                }
+            }, 500);
+        }
+    }
+    setupListeners() {
+        this.discovery.on('update', (status) => {
+            this.log.info(`discovery update: id=${status.id} state=${status.state} topic=${status.topic || '(none)'}`);
+            this.handleHookUpdate(status);
+        });
+        this.discovery.on('remove', (id) => {
+            if (this.instances.has(id) && !this.managedIds.has(id)) {
+                this.instances.delete(id);
+                this.emit('remove', id);
+            }
+        });
+        this.ptyManager.on('data', (instanceId, data) => {
+            this.scrollbackBuffer.append(instanceId, data);
+        });
+        this.ptyManager.on('exit', (instanceId, exitCode) => {
+            const info = this.instances.get(instanceId);
+            this.log.info(`PTY exit event: id=${instanceId} exitCode=${exitCode} name="${info?.name}" state=${info?.state}`);
+            if (info) {
+                info.state = 'stopped';
+                info.stoppedAt = Date.now();
+                info.lastUpdated = Date.now();
+                this.emit('update', info);
+                this.scrollbackBuffer.flushAll();
+                this.sessionStore.save(info);
+            }
+            this.emit('pty:exit', instanceId, exitCode);
+        });
+    }
+    /** Compute ticketUrl from a ticket key and current JIRA settings. */
+    computeTicketUrl(ticket) {
+        if (!ticket)
+            return undefined;
+        if (ticket.startsWith('http'))
+            return ticket;
+        const { baseUrl } = this.settingsManager.get().jira;
+        if (baseUrl) {
+            return `${baseUrl}/browse/${ticket}`;
+        }
+        return undefined;
+    }
+    /** Apply ticket derivation (from branch), ticketUrl, and ticketStatus to an InstanceInfo. */
+    applyTicketFields(info, explicitTicket, explicitTicketStatus) {
+        // Derive ticket from branch if not explicitly set
+        if (!info.ticket) {
+            const derived = extractJiraKey(info.gitBranch);
+            if (derived)
+                info.ticket = derived;
+        }
+        info.ticketUrl = this.computeTicketUrl(info.ticket);
+        // Use explicit status if provided
+        if (explicitTicketStatus) {
+            info.ticketStatus = explicitTicketStatus;
+        }
+        // Schedule async JIRA status fetch if we have a JIRA key and credentials, and no explicit status
+        if (!info.ticketStatus && info.ticket && JIRA_KEY_RE.test(info.ticket)) {
+            const jira = this.settingsManager.get().jira;
+            if (jira.baseUrl && jira.email && jira.apiToken) {
+                this.fetchAndSetJiraStatus(info.id, info.ticket);
+            }
+        }
+    }
+    async fetchAndSetJiraStatus(instanceId, ticketKey) {
+        // Check cache
+        const cached = this.jiraStatusCache.get(ticketKey);
+        if (cached && Date.now() - cached.fetchedAt < 60_000) {
+            const info = this.instances.get(instanceId);
+            if (info && !info.ticketStatus) {
+                info.ticketStatus = cached.status;
+                this.emit('update', info);
+            }
+            return;
+        }
+        const { baseUrl, email, apiToken } = this.settingsManager.get().jira;
+        const status = await fetchJiraStatus(baseUrl, email, apiToken, ticketKey);
+        if (status) {
+            this.jiraStatusCache.set(ticketKey, { status, fetchedAt: Date.now() });
+            const info = this.instances.get(instanceId);
+            if (info) {
+                info.ticketStatus = status;
+                this.emit('update', info);
+            }
+        }
+    }
+    launch(payload) {
+        const id = generateInstanceId();
+        const dirName = payload.cwd.split('/').filter(Boolean).pop() || 'instance';
+        const now = Date.now();
+        const info = {
+            id,
+            name: payload.autoName ? dirName : (payload.name || id),
+            managed: true,
+            cwd: payload.cwd,
+            gitBranch: getGitBranch(payload.cwd),
+            state: 'launching',
+            lastUpdated: now,
+            createdAt: now,
+            model: payload.model,
+            permissionMode: payload.permissionMode,
+        };
+        this.applyTicketFields(info);
+        this.instances.set(id, info);
+        this.managedIds.add(id);
+        if (payload.autoName)
+            this.autoNameIds.add(id);
+        this.subscribers.set(id, new Set());
+        try {
+            this.ptyManager.spawn(id, payload.cwd, {
+                model: payload.model,
+                permissionMode: payload.permissionMode,
+            });
+        }
+        catch (err) {
+            info.state = 'stopped';
+            this.emit('update', info);
+            return info;
+        }
+        this.emit('update', info);
+        this.sessionStore.save(info);
+        this.scheduleLaunchTransition(id);
+        return info;
+    }
+    /** Transition launching → running after 3s if nothing else has changed the state. */
+    scheduleLaunchTransition(instanceId) {
+        setTimeout(() => {
+            const info = this.instances.get(instanceId);
+            if (info && info.state === 'launching') {
+                info.state = 'running';
+                info.lastUpdated = Date.now();
+                this.emit('update', info);
+            }
+        }, 3000);
+    }
+    kill(instanceId) {
+        const info = this.instances.get(instanceId);
+        this.log.info(`kill() called: id=${instanceId} name="${info?.name}" trace=${new Error().stack?.split('\n').slice(1, 4).map(s => s.trim()).join(' <- ')}`);
+        this.ptyManager.kill(instanceId);
+        if (info) {
+            info.state = 'stopped';
+            info.stoppedAt = Date.now();
+            info.lastUpdated = Date.now();
+            this.emit('update', info);
+            this.scrollbackBuffer.flushAll();
+            this.sessionStore.save(info);
+        }
+    }
+    resume(instanceId) {
+        const old = this.instances.get(instanceId);
+        if (!old || !old.managed)
+            return null;
+        const newId = generateInstanceId();
+        const now = Date.now();
+        // Only use --resume with a real session ID from hooks; otherwise use --continue
+        const resumeId = old.claudeSessionId || undefined;
+        const info = {
+            id: newId,
+            name: old.name,
+            managed: true,
+            cwd: old.cwd,
+            state: 'launching',
+            lastUpdated: now,
+            createdAt: now,
+            model: old.model,
+            permissionMode: old.permissionMode,
+            previousInstanceId: instanceId,
+            gitBranch: getGitBranch(old.cwd) || old.gitBranch,
+        };
+        this.instances.set(newId, info);
+        this.managedIds.add(newId);
+        if (this.autoNameIds.has(instanceId)) {
+            this.autoNameIds.add(newId);
+        }
+        const oldPromptCount = this.promptCount.get(instanceId);
+        if (oldPromptCount !== undefined) {
+            this.promptCount.set(newId, oldPromptCount);
+        }
+        this.subscribers.set(newId, new Set());
+        try {
+            this.ptyManager.spawn(newId, old.cwd, {
+                model: old.model,
+                permissionMode: old.permissionMode,
+                claudeSessionId: resumeId,
+                resume: true,
+            });
+        }
+        catch (err) {
+            info.state = 'stopped';
+            this.emit('update', info);
+            return info;
+        }
+        this.emit('update', info);
+        this.sessionStore.save(info);
+        this.scheduleLaunchTransition(newId);
+        // Remove the old stopped instance from the list and disk
+        this.instances.delete(instanceId);
+        this.managedIds.delete(instanceId);
+        this.autoNameIds.delete(instanceId);
+        this.promptCount.delete(instanceId);
+        this.sessionStore.remove(instanceId);
+        this.scrollbackBuffer.remove(instanceId);
+        this.emit('remove', instanceId);
+        return info;
+    }
+    dismiss(instanceId) {
+        this.instances.delete(instanceId);
+        this.managedIds.delete(instanceId);
+        this.subscribers.delete(instanceId);
+        this.sessionStore.remove(instanceId);
+        this.scrollbackBuffer.remove(instanceId);
+        this.emit('remove', instanceId);
+    }
+    getScrollback(instanceId) {
+        return this.scrollbackBuffer.getBuffer(instanceId);
+    }
+    remove(instanceId) {
+        this.instances.delete(instanceId);
+        this.managedIds.delete(instanceId);
+        this.subscribers.delete(instanceId);
+        this.emit('remove', instanceId);
+    }
+    handleHookUpdate(data) {
+        const existing = this.instances.get(data.id);
+        // Completion notification: Notification immediately after Stop = "task done", not permission prompt.
+        // Clear hookEvent so lastHookEvent stays 'Stop' — both POST and file-watcher deliver
+        // each event, so the duplicate must also be suppressed.
+        if (data.hookEvent === 'Notification' && existing?.lastHookEvent === 'Stop') {
+            this.log.info(`suppressing waiting state for ${data.id} — Notification after Stop (task completion, not permission prompt)`);
+            data.state = 'idle';
+            data.hookEvent = undefined;
+        }
+        if (data.state === 'stopped') {
+            this.log.info(`hook update with stopped state: id=${data.id} managed=${this.managedIds.has(data.id)} ptyAlive=${this.ptyManager.has(data.id)}`);
+            // Ignore stopped state from hooks if the PTY is still alive — this happens when
+            // Claude subtasks/subagents end and fire SessionEnd with the parent's instance ID
+            if (this.managedIds.has(data.id) && this.ptyManager.has(data.id)) {
+                this.log.info(`ignoring stopped hook for ${data.id} — PTY still alive (likely subtask exit)`);
+                return;
+            }
+        }
+        // Auto-name: use topic or subtask, refreshing every 5 prompts
+        let name = existing?.name || data.id;
+        if (this.autoNameIds.has(data.id)) {
+            const autoName = data.subtask || data.topic;
+            if (autoName) {
+                // Track prompt count — topic is set on UserPromptSubmit events
+                if (data.topic) {
+                    const count = (this.promptCount.get(data.id) || 0) + 1;
+                    this.promptCount.set(data.id, count);
+                    // Rename on first prompt and every 5 prompts after
+                    if (count === 1 || count % 5 === 0) {
+                        name = autoName;
+                    }
+                }
+                else {
+                    // subtask update without a prompt — always use it
+                    name = autoName;
+                }
+            }
+        }
+        // Capture claude session ID from hook data
+        const claudeSessionId = data.sessionId || existing?.claudeSessionId;
+        const info = {
+            id: data.id,
+            name,
+            managed: this.managedIds.has(data.id),
+            cwd: data.cwd,
+            gitBranch: data.gitBranch,
+            state: data.state,
+            ticket: data.ticket,
+            subtask: data.subtask,
+            progress: data.progress,
+            currentTool: data.currentTool,
+            lastUpdated: data.lastUpdated,
+            model: data.model || existing?.model,
+            createdAt: existing?.createdAt,
+            claudeSessionId,
+        };
+        info.lastHookUpdate = Date.now();
+        info.lastHookEvent = data.hookEvent || existing?.lastHookEvent;
+        this.applyTicketFields(info, data.ticket, data.ticketStatus);
+        this.instances.set(data.id, info);
+        this.emit('update', info);
+        // Save to session store on meaningful hook updates for managed instances
+        if (this.managedIds.has(data.id) && claudeSessionId) {
+            this.sessionStore.save(info);
+        }
+    }
+    getAll() {
+        return Array.from(this.instances.values());
+    }
+    get(id) {
+        return this.instances.get(id);
+    }
+    isManaged(id) {
+        return this.managedIds.has(id);
+    }
+    /** Save all running instances as stopped (for graceful shutdown). */
+    saveAllAsStopped() {
+        this.log.info(`saveAllAsStopped() called — shutting down`);
+        const now = Date.now();
+        for (const [id, info] of this.instances) {
+            if (this.managedIds.has(id) && info.state !== 'stopped') {
+                this.log.info(`marking stopped for shutdown: id=${id} name="${info.name}"`);
+                info.state = 'stopped';
+                info.stoppedAt = now;
+                info.lastUpdated = now;
+                this.sessionStore.save(info, { autoResume: true });
+            }
+        }
+    }
+    staleCheckCycle = 0;
+    startStaleCheck() {
+        this.staleTimer = setInterval(() => {
+            const now = Date.now();
+            this.staleCheckCycle++;
+            for (const [id, info] of this.instances) {
+                if (info.state === 'stopped')
+                    continue;
+                // Tiered git branch refresh for managed instances
+                if (this.managedIds.has(id) && info.state !== 'launching') {
+                    const shouldRefreshGit = info.state === 'running' || info.state === 'waiting'
+                        ? true // every cycle (10s)
+                        : this.staleCheckCycle % 6 === 0; // idle: every 6th cycle (60s)
+                    if (shouldRefreshGit) {
+                        const branch = getGitBranch(info.cwd);
+                        if (branch && branch !== info.gitBranch) {
+                            info.gitBranch = branch;
+                            this.emit('update', info);
+                        }
+                    }
+                }
+                // Terminal-based state fallback for managed instances
+                if (this.managedIds.has(id)) {
+                    const hookSilent = !info.lastHookUpdate || (now - info.lastHookUpdate > HOOK_SILENCE_THRESHOLD_MS);
+                    // Check if PTY is dead but state isn't stopped
+                    if (!this.ptyManager.has(id)) {
+                        this.log.info(`stale check: PTY dead for ${id} (${info.name}), marking stopped`);
+                        info.state = 'stopped';
+                        info.stoppedAt = now;
+                        info.lastUpdated = now;
+                        this.emit('update', info);
+                        this.sessionStore.save(info);
+                        continue;
+                    }
+                    // If hooks have been silent, try terminal-based detection
+                    if (hookSilent) {
+                        const tail = this.scrollbackBuffer.getTail(id, 500);
+                        const detected = detectStateFromTerminal(tail);
+                        if (detected && detected !== info.state) {
+                            this.log.info(`terminal fallback: ${id} (${info.name}) ${info.state} → ${detected}`);
+                            info.state = detected;
+                            info.lastUpdated = now;
+                            this.emit('update', info);
+                        }
+                    }
+                }
+            }
+        }, 10_000);
+    }
+    /** Recompute ticket URLs for all instances (call after JIRA settings change). */
+    refreshTicketFields() {
+        for (const info of this.instances.values()) {
+            const oldUrl = info.ticketUrl;
+            info.ticketUrl = this.computeTicketUrl(info.ticket);
+            if (info.ticketUrl !== oldUrl) {
+                this.emit('update', info);
+            }
+        }
+    }
+    stop() {
+        if (this.staleTimer)
+            clearInterval(this.staleTimer);
+        this.discovery.stop();
+    }
+}

package/dist/server/server/jira-client.js

@@ -0,0 +1,33 @@
+import { createLogger } from './util/logger.js';
+const log = createLogger('jira');
+export async function fetchJiraStatus(baseUrl, email, apiToken, issueKey) {
+    const url = `${baseUrl}/rest/api/3/issue/${encodeURIComponent(issueKey)}?fields=status`;
+    const auth = Buffer.from(`${email}:${apiToken}`).toString('base64');
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const res = await fetch(url, {
+            headers: {
+                Authorization: `Basic ${auth}`,
+                Accept: 'application/json',
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!res.ok) {
+            log.error(`JIRA API returned ${res.status} for ${issueKey}`);
+            return null;
+        }
+        const data = await res.json();
+        return data?.fields?.status?.name ?? null;
+    }
+    catch (err) {
+        if (err.name === 'AbortError') {
+            log.error(`JIRA API timeout for ${issueKey}`);
+        }
+        else {
+            log.error(`JIRA API error for ${issueKey}:`, err.message);
+        }
+        return null;
+    }
+}

package/dist/server/server/pty-manager.js

@@ -0,0 +1,98 @@
+import * as pty from '@lydell/node-pty';
+import os from 'os';
+import { EventEmitter } from 'events';
+import { getDefaultShell, getShellArgs } from './util/platform.js';
+import { shellQuote, isValidModel, isValidPermissionMode, isValidSessionId } from './util/sanitize.js';
+import { createLogger } from './util/logger.js';
+function expandHome(p) {
+    let resolved = p;
+    if (resolved.startsWith('~/') || resolved === '~') {
+        resolved = os.homedir() + resolved.slice(1);
+    }
+    // Strip trailing slash (node-pty can choke on it)
+    if (resolved.length > 1 && resolved.endsWith('/')) {
+        resolved = resolved.slice(0, -1);
+    }
+    return resolved;
+}
+const log = createLogger('pty');
+export class PtyManager extends EventEmitter {
+    ptys = new Map();
+    spawn(instanceId, cwd, opts) {
+        const shell = getDefaultShell();
+        const args = getShellArgs(shell);
+        const resolvedCwd = expandHome(cwd);
+        log.info(`Spawning: shell=${shell} cwd=${resolvedCwd} id=${instanceId}`);
+        let p;
+        try {
+            p = pty.spawn(shell, args, {
+                name: 'xterm-256color',
+                cols: 120,
+                rows: 30,
+                cwd: resolvedCwd,
+                env: {
+                    ...process.env,
+                    MOB_INSTANCE_ID: instanceId,
+                    TERM: 'xterm-256color',
+                },
+            });
+        }
+        catch (err) {
+            log.error(`Failed to spawn PTY:`, err);
+            this.emit('error', instanceId, err);
+            throw err;
+        }
+        log.info(`PTY spawned: pid=${p.pid}`);
+        this.ptys.set(instanceId, p);
+        p.onData((data) => {
+            this.emit('data', instanceId, data);
+        });
+        p.onExit(({ exitCode }) => {
+            log.info(`PTY exited: id=${instanceId} code=${exitCode}`);
+            this.ptys.delete(instanceId);
+            this.emit('exit', instanceId, exitCode);
+        });
+        // Build claude command with validated & shell-quoted arguments
+        setTimeout(() => {
+            let cmd = 'claude';
+            if (opts?.claudeSessionId && isValidSessionId(opts.claudeSessionId)) {
+                cmd += ` --resume ${shellQuote(opts.claudeSessionId)}`;
+            }
+            else if (opts?.resume) {
+                cmd += ' --continue';
+            }
+            if (!opts?.claudeSessionId && !opts?.resume) {
+                cmd += ` --name ${shellQuote('mob-' + instanceId)}`;
+            }
+            if (opts?.model && isValidModel(opts.model)) {
+                cmd += ` --model ${shellQuote(opts.model)}`;
+            }
+            if (opts?.permissionMode && isValidPermissionMode(opts.permissionMode)) {
+                cmd += ` --permission-mode ${shellQuote(opts.permissionMode)}`;
+            }
+            log.info(`Sending command: ${cmd}`);
+            p.write(cmd + '\r');
+        }, 500);
+        return p;
+    }
+    write(instanceId, data) {
+        this.ptys.get(instanceId)?.write(data);
+    }
+    resize(instanceId, cols, rows) {
+        this.ptys.get(instanceId)?.resize(cols, rows);
+    }
+    kill(instanceId) {
+        const p = this.ptys.get(instanceId);
+        if (p) {
+            log.info(`Killing PTY: id=${instanceId} pid=${p.pid}`);
+            p.kill();
+            this.ptys.delete(instanceId);
+        }
+    }
+    has(instanceId) {
+        return this.ptys.has(instanceId);
+    }
+    getAll() {
+        return this.ptys;
+    }
+}

package/dist/server/server/scrollback-buffer.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+import { getScrollbackDir } from './util/platform.js';
+import { SCROLLBACK_MAX_BYTES, SCROLLBACK_FLUSH_MS } from '../shared/constants.js';
+function log(...args) {
+    const ts = new Date().toISOString().slice(11, 23);
+    console.log(`[${ts}] [scrollback]`, ...args);
+}
+export class ScrollbackBuffer {
+    buffers = new Map();
+    flushTimer = null;
+    start() {
+        this.flushTimer = setInterval(() => this.flushDirty(), SCROLLBACK_FLUSH_MS);
+    }
+    append(instanceId, data) {
+        let entry = this.buffers.get(instanceId);
+        if (!entry) {
+            entry = { chunks: [], byteLength: 0, dirty: false };
+            this.buffers.set(instanceId, entry);
+        }
+        const bytes = Buffer.byteLength(data, 'utf8');
+        entry.chunks.push(data);
+        entry.byteLength += bytes;
+        entry.dirty = true;
+        // Trim oldest chunks if over max
+        while (entry.byteLength > SCROLLBACK_MAX_BYTES && entry.chunks.length > 1) {
+            const removed = entry.chunks.shift();
+            entry.byteLength -= Buffer.byteLength(removed, 'utf8');
+        }
+    }
+    getTail(instanceId, chars) {
+        const entry = this.buffers.get(instanceId);
+        if (!entry || entry.chunks.length === 0)
+            return '';
+        // Walk chunks from the end, collecting up to `chars` characters
+        let result = '';
+        for (let i = entry.chunks.length - 1; i >= 0 && result.length < chars; i--) {
+            result = entry.chunks[i] + result;
+        }
+        return result.length > chars ? result.slice(-chars) : result;
+    }
+    getBuffer(instanceId) {
+        const entry = this.buffers.get(instanceId);
+        if (entry)
+            return entry.chunks.join('');
+        // Try reading from disk
+        const filePath = path.join(getScrollbackDir(), `${instanceId}.log`);
+        try {
+            return fs.readFileSync(filePath, 'utf8');
+        }
+        catch {
+            return '';
+        }
+    }
+    flushDirty() {
+        const dir = getScrollbackDir();
+        for (const [instanceId, entry] of this.buffers) {
+            if (!entry.dirty)
+                continue;
+            try {
+                const filePath = path.join(dir, `${instanceId}.log`);
+                fs.writeFileSync(filePath, entry.chunks.join(''), 'utf8');
+                entry.dirty = false;
+            }
+            catch (err) {
+                log(`Failed to flush ${instanceId}:`, err);
+            }
+        }
+    }
+    flushAll() {
+        const dir = getScrollbackDir();
+        for (const [instanceId, entry] of this.buffers) {
+            if (!entry.dirty)
+                continue;
+            try {
+                const filePath = path.join(dir, `${instanceId}.log`);
+                fs.writeFileSync(filePath, entry.chunks.join(''), 'utf8');
+                entry.dirty = false;
+            }
+            catch (err) {
+                log(`Failed to flush ${instanceId}:`, err);
+            }
+        }
+    }
+    remove(instanceId) {
+        this.buffers.delete(instanceId);
+        const filePath = path.join(getScrollbackDir(), `${instanceId}.log`);
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch {
+            // File may not exist
+        }
+    }
+    stop() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.flushAll();
+    }
+}