@harness-fe/mcp-server 3.0.1

package/dist/replayCreate.js

@@ -0,0 +1,156 @@
+/**
+ * Shared replay-export logic used by both the leader's MCP tool handler and
+ * the leader's mcp.call dispatcher (for follower proxy calls).
+ *
+ * Takes a time window (or a center timestamp), pulls the overlapping rrweb
+ * chunks for a single tab, concatenates the events, persists them as an
+ * export, and returns the metadata + viewerUrl.
+ */
+/** rrweb event types: 2 = FullSnapshot baseline. Replay needs at least one. */
+function isFullSnapshotEvent(ev) {
+    return (typeof ev === 'object' &&
+        ev !== null &&
+        ev.type === 2);
+}
+export function createReplayExport(store, baseUrl, input) {
+    const { sessionId, tabId, ts, windowMs, since, until, label } = input;
+    const session = store.getSession(sessionId);
+    if (!session) {
+        return { error: 'session not found', sessionId, since: since ?? 0, until: until ?? 0 };
+    }
+    let resolvedSince;
+    let resolvedUntil;
+    if (typeof since === 'number' && typeof until === 'number') {
+        if (until <= since) {
+            return { error: 'until must be greater than since', sessionId, since, until };
+        }
+        resolvedSince = since;
+        resolvedUntil = until;
+    }
+    else if (typeof ts === 'number') {
+        const radius = windowMs ?? 15_000;
+        resolvedSince = ts - radius;
+        resolvedUntil = ts + radius;
+    }
+    else {
+        return {
+            error: 'must provide either ts (with optional windowMs) or both since and until',
+            sessionId,
+            since: 0,
+            until: 0,
+        };
+    }
+    const chunks = store.sliceRecordings(sessionId, resolvedSince, resolvedUntil);
+    if (chunks.length === 0) {
+        return {
+            error: 'no rrweb chunks found in window',
+            sessionId,
+            tabId,
+            since: resolvedSince,
+            until: resolvedUntil,
+        };
+    }
+    let scopedTabId = tabId;
+    if (!scopedTabId) {
+        const byTab = new Map();
+        for (const c of chunks)
+            byTab.set(c.tabId, (byTab.get(c.tabId) ?? 0) + c.eventCount);
+        let best = '';
+        let bestEvents = -1;
+        for (const [t, count] of byTab) {
+            if (count > bestEvents) {
+                best = t;
+                bestEvents = count;
+            }
+        }
+        scopedTabId = best;
+    }
+    const tabChunks = chunks.filter((c) => c.tabId === scopedTabId);
+    const events = [];
+    let startTs = Infinity;
+    let endTs = -Infinity;
+    for (const c of tabChunks) {
+        for (const ev of c.events)
+            events.push(ev);
+        if (c.startTs < startTs)
+            startTs = c.startTs;
+        if (c.endTs > endTs)
+            endTs = c.endTs;
+    }
+    // rrweb replay requires a baseline pair — type:4 (Meta) + type:2
+    // (FullSnapshot) — before any type:3 (IncrementalSnapshot) is meaningful.
+    // If the window only contains incremental mutations (e.g. user picked a
+    // narrow window long after the page loaded, or the very first chunk was
+    // lost during a daemon restart), look back across earlier chunks for the
+    // most recent baseline and prepend it. Replay will then start from that
+    // earlier DOM state and roll mutations forward into the window.
+    if (!events.some(isFullSnapshotEvent) && resolvedSince > 0) {
+        const priorChunks = store
+            .sliceRecordings(sessionId, 0, resolvedSince - 1)
+            .filter((c) => c.tabId === scopedTabId)
+            .sort((a, b) => a.startTs - b.startTs);
+        // Walk backwards from the chunk closest to window start; the first
+        // chunk that has a FullSnapshot becomes our baseline.
+        for (let i = priorChunks.length - 1; i >= 0; i--) {
+            const baseline = priorChunks[i];
+            if (!baseline)
+                continue;
+            if (baseline.events.some(isFullSnapshotEvent)) {
+                // Prepend baseline events (full chunk — preserves Meta + FS
+                // ordering rrweb emitted them in). startTs widens to baseline.
+                events.unshift(...baseline.events);
+                if (baseline.startTs < startTs)
+                    startTs = baseline.startTs;
+                break;
+            }
+        }
+    }
+    if (events.length < 2) {
+        return {
+            error: 'window contains fewer than 2 rrweb events — not enough to replay',
+            sessionId,
+            tabId: scopedTabId,
+            since: resolvedSince,
+            until: resolvedUntil,
+            eventCount: events.length,
+        };
+    }
+    if (!events.some(isFullSnapshotEvent)) {
+        return {
+            error: 'window contains no rrweb FullSnapshot (type:2) baseline, and no earlier baseline could be found — replay would be blank',
+            sessionId,
+            tabId: scopedTabId,
+            since: resolvedSince,
+            until: resolvedUntil,
+            eventCount: events.length,
+        };
+    }
+    const meta = store.writeExport({
+        sessionId,
+        tabId: scopedTabId,
+        since: resolvedSince,
+        until: resolvedUntil,
+        label,
+        events,
+        startTs,
+        endTs,
+        chunkCount: tabChunks.length,
+    });
+    const viewerUrl = baseUrl ? `${baseUrl}/replay/${meta.exportId}` : undefined;
+    return {
+        exportId: meta.exportId,
+        viewerUrl,
+        sessionId,
+        tabId: scopedTabId,
+        since: resolvedSince,
+        until: resolvedUntil,
+        startTs,
+        endTs,
+        durationMs: endTs - startTs,
+        eventCount: meta.eventCount,
+        chunkCount: meta.chunkCount,
+        bytes: meta.bytes,
+        createdAt: meta.createdAt,
+        label,
+    };
+}

package/dist/replayViewer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Replay viewer — HTTP routes for serving exported rrweb recordings.
+ *
+ * Routes (all served on the same port as the WS bridge):
+ *   GET /replay/:id           HTML viewer page (rrweb-player UI)
+ *   GET /replay/:id.json      Raw events array for the player to fetch
+ *   GET /replay/static/player.js   Bundled rrweb-player (UMD)
+ *   GET /replay/static/player.css  Bundled rrweb-player styles
+ *
+ * The HTML page loads the static assets relatively and then calls
+ * /replay/:id.json to hydrate the player. This keeps the viewer self-contained
+ * and offline-capable — no CDN dependencies.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { IStore } from './store/index.js';
+/**
+ * Build a handler that dispatches /replay/* requests. Returns undefined for
+ * non-replay paths so the caller can chain or 404.
+ */
+export declare function createReplayHandler(store: IStore): (req: IncomingMessage, res: ServerResponse) => boolean;

package/dist/replayViewer.js

@@ -0,0 +1,168 @@
+/**
+ * Replay viewer — HTTP routes for serving exported rrweb recordings.
+ *
+ * Routes (all served on the same port as the WS bridge):
+ *   GET /replay/:id           HTML viewer page (rrweb-player UI)
+ *   GET /replay/:id.json      Raw events array for the player to fetch
+ *   GET /replay/static/player.js   Bundled rrweb-player (UMD)
+ *   GET /replay/static/player.css  Bundled rrweb-player styles
+ *
+ * The HTML page loads the static assets relatively and then calls
+ * /replay/:id.json to hydrate the player. This keeps the viewer self-contained
+ * and offline-capable — no CDN dependencies.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+const require = createRequire(import.meta.url);
+/** Locate the bundled rrweb-player dist directory. */
+function resolvePlayerDist() {
+    // rrweb-player exposes package.json; use it to find the dist folder.
+    const pkgPath = require.resolve('rrweb-player/package.json');
+    return join(dirname(pkgPath), 'dist');
+}
+const PLAYER_DIST = (() => {
+    try {
+        return resolvePlayerDist();
+    }
+    catch {
+        return '';
+    }
+})();
+const VIEWER_HTML = (exportId, meta) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Harness replay · ${escapeHtml(exportId)}</title>
+<link rel="stylesheet" href="/replay/static/player.css" />
+<style>
+  html, body { margin: 0; padding: 0; background: #1a1a1a; color: #eee; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }
+  .meta { padding: 12px 16px; font-size: 13px; color: #aaa; border-bottom: 1px solid #333; }
+  .meta code { color: #6cf; }
+  .stage { padding: 16px; display: flex; justify-content: center; }
+  .error { padding: 24px; color: #f66; }
+</style>
+</head>
+<body>
+<div class="meta">
+  Replay <code>${escapeHtml(exportId)}</code> · session <code>${escapeHtml(meta.sessionId)}</code>${meta.tabId ? ` · tab <code>${escapeHtml(meta.tabId)}</code>` : ''} · ${meta.eventCount} events · ${Math.round(meta.durationMs / 100) / 10}s
+</div>
+<div class="stage" id="stage"></div>
+<script src="/replay/static/player.js"></script>
+<script>
+  (async function() {
+    const stage = document.getElementById('stage');
+    try {
+      const resp = await fetch(${JSON.stringify(`/replay/${exportId}.json`)});
+      if (!resp.ok) throw new Error('failed to fetch events: ' + resp.status);
+      const events = await resp.json();
+      if (!Array.isArray(events) || events.length < 2) {
+        throw new Error('export has fewer than 2 events — cannot play back');
+      }
+      // rrwebPlayer is the UMD global.
+      new rrwebPlayer({
+        target: stage,
+        props: {
+          events,
+          autoPlay: true,
+          showController: true,
+          width: Math.min(1280, window.innerWidth - 64),
+          height: Math.min(720, window.innerHeight - 120),
+        },
+      });
+    } catch (err) {
+      stage.innerHTML = '<div class="error">Replay failed: ' + (err && err.message ? String(err.message).replace(/[<>&]/g, '') : 'unknown error') + '</div>';
+      console.error('[harness replay]', err);
+    }
+  })();
+</script>
+</body>
+</html>`;
+function escapeHtml(s) {
+    return s.replace(/[&<>"']/g, (ch) => {
+        switch (ch) {
+            case '&': return '&amp;';
+            case '<': return '&lt;';
+            case '>': return '&gt;';
+            case '"': return '&quot;';
+            default: return '&#39;';
+        }
+    });
+}
+function send(res, status, contentType, body) {
+    res.statusCode = status;
+    res.setHeader('content-type', contentType);
+    res.setHeader('cache-control', 'no-store');
+    res.end(body);
+}
+/**
+ * Build a handler that dispatches /replay/* requests. Returns undefined for
+ * non-replay paths so the caller can chain or 404.
+ */
+export function createReplayHandler(store) {
+    return (req, res) => {
+        if (!req.url)
+            return false;
+        const url = new URL(req.url, 'http://localhost');
+        const path = url.pathname;
+        if (!path.startsWith('/replay/'))
+            return false;
+        // Static assets
+        if (path === '/replay/static/player.js') {
+            if (!PLAYER_DIST)
+                return reply500(res, 'rrweb-player not installed');
+            const file = join(PLAYER_DIST, 'index.js');
+            if (!existsSync(file))
+                return reply500(res, 'rrweb-player bundle missing');
+            send(res, 200, 'application/javascript; charset=utf-8', readFileSync(file));
+            return true;
+        }
+        if (path === '/replay/static/player.css') {
+            if (!PLAYER_DIST)
+                return reply500(res, 'rrweb-player not installed');
+            const file = join(PLAYER_DIST, 'style.css');
+            if (!existsSync(file))
+                return reply500(res, 'rrweb-player styles missing');
+            send(res, 200, 'text/css; charset=utf-8', readFileSync(file));
+            return true;
+        }
+        // /replay/:id or /replay/:id.json
+        const tail = path.slice('/replay/'.length);
+        if (!tail || tail.includes('/')) {
+            send(res, 404, 'text/plain; charset=utf-8', 'Not Found');
+            return true;
+        }
+        const isJson = tail.endsWith('.json');
+        const exportId = isJson ? tail.slice(0, -'.json'.length) : tail;
+        if (!/^[A-Za-z0-9_-]+$/.test(exportId)) {
+            send(res, 400, 'text/plain; charset=utf-8', 'Invalid export id');
+            return true;
+        }
+        const meta = store.getExport(exportId);
+        if (!meta) {
+            send(res, 404, 'text/plain; charset=utf-8', `Unknown export: ${exportId}`);
+            return true;
+        }
+        if (isJson) {
+            const events = store.readExportEvents(exportId);
+            if (!events) {
+                send(res, 404, 'application/json; charset=utf-8', '{"error":"export events missing"}');
+                return true;
+            }
+            send(res, 200, 'application/json; charset=utf-8', JSON.stringify(events));
+            return true;
+        }
+        const html = VIEWER_HTML(exportId, {
+            sessionId: meta.sessionId,
+            tabId: meta.tabId,
+            durationMs: Math.max(0, meta.endTs - meta.startTs),
+            eventCount: meta.eventCount,
+        });
+        send(res, 200, 'text/html; charset=utf-8', html);
+        return true;
+    };
+    function reply500(res, msg) {
+        send(res, 500, 'text/plain; charset=utf-8', msg);
+        return true;
+    }
+}

package/dist/sessionRouter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * SessionRouter — registry of connected peers (vite-plugin + runtime-client).
+ *
+ * - Project: 1 vite-plugin per project (uniqued by projectId)
+ * - Tab    : N runtime-clients per project (each browser tab is one)
+ *
+ * Active tab heuristic: most recently active (last command or last event).
+ * Caller can override via explicit tabId on every command.
+ */
+import type { PeerRole, TabInfo } from '@harness-fe/protocol';
+export interface PeerSession {
+    role: PeerRole;
+    projectId: string;
+    tabId?: string;
+    /** Runtime-client only: identifies the page load (sessionId) this connection belongs to. */
+    sessionId?: string;
+    /** Runtime-client only: stable per-browser visitor identifier. */
+    visitorId?: string;
+    /** App-supplied user identifier propagated from HarnessScript userId prop. */
+    userId?: string;
+    /** Opaque identifier for the underlying connection. */
+    connectionId: string;
+    lastActive: number;
+    page?: {
+        url?: string;
+        title?: string;
+        userAgent?: string;
+    };
+}
+export declare class SessionRouter {
+    private peers;
+    private mostRecentTabId?;
+    register(session: Omit<PeerSession, 'lastActive'>): PeerSession;
+    unregister(connectionId: string): void;
+    touch(connectionId: string): void;
+    getByConnectionId(connectionId: string): PeerSession | undefined;
+    findVitePlugin(projectId?: string): PeerSession | undefined;
+    findTab(tabId?: string): PeerSession | undefined;
+    private findFallbackTab;
+    listTabs(): TabInfo[];
+    listProjects(): string[];
+}

package/dist/sessionRouter.js

@@ -0,0 +1,88 @@
+/**
+ * SessionRouter — registry of connected peers (vite-plugin + runtime-client).
+ *
+ * - Project: 1 vite-plugin per project (uniqued by projectId)
+ * - Tab    : N runtime-clients per project (each browser tab is one)
+ *
+ * Active tab heuristic: most recently active (last command or last event).
+ * Caller can override via explicit tabId on every command.
+ */
+export class SessionRouter {
+    peers = new Map(); // key = connectionId
+    mostRecentTabId;
+    register(session) {
+        const stored = { ...session, lastActive: Date.now() };
+        this.peers.set(session.connectionId, stored);
+        if (session.role === 'runtime-client' && session.tabId) {
+            this.mostRecentTabId = session.tabId;
+        }
+        return stored;
+    }
+    unregister(connectionId) {
+        const peer = this.peers.get(connectionId);
+        this.peers.delete(connectionId);
+        if (peer?.tabId && this.mostRecentTabId === peer.tabId) {
+            this.mostRecentTabId = this.findFallbackTab()?.tabId;
+        }
+    }
+    touch(connectionId) {
+        const peer = this.peers.get(connectionId);
+        if (!peer)
+            return;
+        peer.lastActive = Date.now();
+        if (peer.role === 'runtime-client' && peer.tabId) {
+            this.mostRecentTabId = peer.tabId;
+        }
+    }
+    getByConnectionId(connectionId) {
+        return this.peers.get(connectionId);
+    }
+    findVitePlugin(projectId) {
+        const candidates = [...this.peers.values()].filter((p) => p.role === 'vite-plugin' || p.role === 'webpack-plugin');
+        if (!candidates.length)
+            return undefined;
+        if (projectId)
+            return candidates.find((c) => c.projectId === projectId);
+        // No projectId filter — return the most recent.
+        return candidates.sort((a, b) => b.lastActive - a.lastActive)[0];
+    }
+    findTab(tabId) {
+        if (tabId) {
+            for (const p of this.peers.values()) {
+                if (p.role === 'runtime-client' && p.tabId === tabId)
+                    return p;
+            }
+            return undefined;
+        }
+        if (this.mostRecentTabId) {
+            return this.findTab(this.mostRecentTabId);
+        }
+        return this.findFallbackTab();
+    }
+    findFallbackTab() {
+        const tabs = [...this.peers.values()]
+            .filter((p) => p.role === 'runtime-client' && p.tabId)
+            .sort((a, b) => b.lastActive - a.lastActive);
+        return tabs[0];
+    }
+    listTabs() {
+        return [...this.peers.values()]
+            .filter((p) => p.role === 'runtime-client' && !!p.tabId)
+            .map((p) => ({
+            tabId: p.tabId,
+            projectId: p.projectId,
+            url: p.page?.url,
+            title: p.page?.title,
+            userAgent: p.page?.userAgent,
+            connectedAt: p.lastActive,
+        }));
+    }
+    listProjects() {
+        const ids = new Set();
+        for (const p of this.peers.values()) {
+            if (p.role === 'vite-plugin' || p.role === 'webpack-plugin')
+                ids.add(p.projectId);
+        }
+        return [...ids];
+    }
+}

package/dist/store/JsonMemoryStore.d.ts

@@ -0,0 +1,52 @@
+/**
+ * JsonMemoryStore — JSON-based persistence for agent memory (key-value store per project).
+ *
+ * File layout:
+ *   {dataDir}/{projectId}/memory.json
+ *
+ * File format:
+ *   {
+ *     "key1": { "key": "key1", "value": "...", "updatedAt": 1700000000000 },
+ *     "key2": { "key": "key2", "value": "...", "updatedAt": 1700000001000 }
+ *   }
+ *
+ * All mutations use atomic write-then-rename for durability.
+ */
+import type { IMemoryStore, MemoryEntry } from './types.js';
+export declare class JsonMemoryStore implements IMemoryStore {
+    private readonly dataDir;
+    constructor(dataDir: string);
+    private memoryPath;
+    /**
+     * Read and parse memory.json for a project.
+     * Returns a null-prototype object on missing or corrupt file (never throws).
+     * Using Object.create(null) prevents prototype pollution from keys like __proto__.
+     */
+    private load;
+    /**
+     * Atomically write memory data to disk using tmp + rename strategy.
+     * Logs error on failure without throwing.
+     */
+    private save;
+    /**
+     * Get a memory entry by key.
+     * Returns undefined if the key does not exist or memory.json is missing.
+     */
+    get(projectId: string, key: string): MemoryEntry | undefined;
+    /**
+     * Write or update a memory entry.
+     * Sets updatedAt to the current Unix ms timestamp.
+     * Returns the new/updated MemoryEntry.
+     */
+    set(projectId: string, key: string, value: string): MemoryEntry;
+    /**
+     * Delete a memory entry by key.
+     * Returns true if the key existed and was removed, false otherwise.
+     */
+    delete(projectId: string, key: string): boolean;
+    /**
+     * List all memory entries for a project, sorted by updatedAt descending.
+     * Returns an empty array if memory.json does not exist.
+     */
+    list(projectId: string): MemoryEntry[];
+}

package/dist/store/JsonMemoryStore.js

@@ -0,0 +1,119 @@
+/**
+ * JsonMemoryStore — JSON-based persistence for agent memory (key-value store per project).
+ *
+ * File layout:
+ *   {dataDir}/{projectId}/memory.json
+ *
+ * File format:
+ *   {
+ *     "key1": { "key": "key1", "value": "...", "updatedAt": 1700000000000 },
+ *     "key2": { "key": "key2", "value": "...", "updatedAt": 1700000001000 }
+ *   }
+ *
+ * All mutations use atomic write-then-rename for durability.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { sanitizeId } from './JsonlStore.js';
+export class JsonMemoryStore {
+    dataDir;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+    }
+    // ── Path helpers ──────────────────────────────────────────────────────
+    memoryPath(projectId) {
+        return join(this.dataDir, sanitizeId(projectId), 'memory.json');
+    }
+    // ── Private I/O ───────────────────────────────────────────────────────
+    /**
+     * Read and parse memory.json for a project.
+     * Returns a null-prototype object on missing or corrupt file (never throws).
+     * Using Object.create(null) prevents prototype pollution from keys like __proto__.
+     */
+    load(projectId) {
+        const path = this.memoryPath(projectId);
+        try {
+            const raw = readFileSync(path, 'utf-8');
+            const parsed = JSON.parse(raw);
+            // Copy into a null-prototype object to prevent prototype pollution
+            const safe = Object.create(null);
+            for (const key of Object.keys(parsed)) {
+                safe[key] = parsed[key];
+            }
+            return safe;
+        }
+        catch {
+            return Object.create(null);
+        }
+    }
+    /**
+     * Atomically write memory data to disk using tmp + rename strategy.
+     * Logs error on failure without throwing.
+     */
+    save(projectId, data) {
+        const path = this.memoryPath(projectId);
+        const tmpPath = `${path}.tmp`;
+        // Ensure the project directory exists
+        const dir = join(this.dataDir, sanitizeId(projectId));
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch (err) {
+            console.error(`[JsonMemoryStore] failed to create directory ${dir}:`, err);
+            return;
+        }
+        try {
+            writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf-8');
+            renameSync(tmpPath, path);
+        }
+        catch (err) {
+            console.error(`[JsonMemoryStore] failed to write ${path}:`, err);
+        }
+    }
+    // ── IMemoryStore implementation ───────────────────────────────────────
+    /**
+     * Get a memory entry by key.
+     * Returns undefined if the key does not exist or memory.json is missing.
+     */
+    get(projectId, key) {
+        const data = this.load(projectId);
+        return data[key];
+    }
+    /**
+     * Write or update a memory entry.
+     * Sets updatedAt to the current Unix ms timestamp.
+     * Returns the new/updated MemoryEntry.
+     */
+    set(projectId, key, value) {
+        const data = this.load(projectId);
+        const entry = {
+            key,
+            value,
+            updatedAt: Date.now(),
+        };
+        data[key] = entry;
+        this.save(projectId, data);
+        return entry;
+    }
+    /**
+     * Delete a memory entry by key.
+     * Returns true if the key existed and was removed, false otherwise.
+     */
+    delete(projectId, key) {
+        const data = this.load(projectId);
+        if (!(key in data)) {
+            return false;
+        }
+        delete data[key];
+        this.save(projectId, data);
+        return true;
+    }
+    /**
+     * List all memory entries for a project, sorted by updatedAt descending.
+     * Returns an empty array if memory.json does not exist.
+     */
+    list(projectId) {
+        const data = this.load(projectId);
+        return Object.values(data).sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+}

package/dist/store/JsonTaskStore.d.ts

@@ -0,0 +1,21 @@
+/**
+ * JsonTaskStore — JSON-based persistence for annotation tasks.
+ *
+ * File format: {dataDir}/{sanitizeId(projectId)}/tasks.json
+ * ```json
+ * { "version": 1, "tasks": Task[] }
+ * ```
+ *
+ * Writes are atomic: write to a .tmp file then rename to the final path.
+ * On read failure (missing or corrupt file), returns an empty array.
+ * On write failure, logs the error without throwing.
+ */
+import type { Task } from '@harness-fe/protocol';
+import type { ITaskStore } from './types.js';
+export declare class JsonTaskStore implements ITaskStore {
+    private readonly dataDir;
+    constructor(dataDir: string);
+    private tasksPath;
+    loadTasks(projectId: string): Task[];
+    saveTasks(projectId: string, tasks: Task[]): void;
+}