mooteam-mcp 0.2.1 → 0.3.0

package/README.md

@@ -15,7 +15,11 @@ This is an independent community integration, not an official Moo.team product.
 - Adds user-confirmed participant roles from an optional local directory.
 - Separates human discussion from optional activity history.
 - Associates files with their task description or specific comment.
-- Returns supported images as MCP image content, PDF embedded text and UTF-8 text.
+- Searches task titles/descriptions by project, assignee and lifecycle status.
+- Reads parents, subtasks and task links with their discussion source.
+- Compares reads using a bounded gzip history of fingerprints, without storing task bodies.
+- Updates user-confirmed roles through MCP in a local directory.
+- Reads images, PDF text/page images, DOCX/XLSX/PPTX text, ZIP listings and text members.
 - Reports incomplete pagination, unsupported formats and truncated extraction.
 - Accepts old `app.moo.team` links, new `new-app.moo.team` task links and numeric IDs.
 
@@ -70,18 +74,34 @@ Listing an attachment does not mean its contents have been read.
 
 | Tool | Purpose |
 |---|---|
-| `get_task_context` | Task details, attributed comments, file manifest and optional history |
+| `get_task_context` | Task details, attributed comments, file manifest and changes since last read |
 | `read_attachment` | Read a file belonging to that task or its visible comments |
+| `get_task_changes` | Compare current data with the last local baseline |
+| `get_related_tasks` | Read parents, subtasks and tasks linked in discussion |
+| `search_tasks` | Search titles/descriptions with bounded collection scanning |
+| `list_projects` | Discover accessible project names and IDs |
+| `list_participants` | Resolve people and their local roles |
+| `set_participant_role` | Save an explicitly supplied role locally |
 
 ## Boundaries
 
-The server exposes only reads. It cannot post comments, change tasks, track time
-or upload files. Access is limited by the configured Moo.team account's permissions.
+All Moo.team requests are GET-only. The server cannot post comments, change tasks,
+track time or upload files. It can update local history and participant roles.
+Access is limited by the configured Moo.team account's permissions.
 It uses observed application API endpoints, which may change without notice.
 
-Images have a 5 MiB output limit. PDF extraction reads embedded text, with no OCR
-or interpretation of diagrams. Word, Excel, archives, audio and video are listed
-but not extracted in this release. External links are retained without fetching them.
+Attachment bytes and rendered pages stay in memory; there is no attachment cache
+or document temporary directory. Images have a 5 MiB output limit. Selected PDF
+pages can be returned as images for the assistant to inspect scans and diagrams;
+there is no automatic OCR transcript. Office extraction reads text and reports
+visual/layout limitations. Legacy DOC/XLS/PPT, audio, video and non-ZIP archives
+are unsupported. External links are retained without fetching them.
+
+History defaults to at most **1 MiB compressed per workspace**, 200 tasks and
+90 days since last observation, with at most 20 change events per task. It stores
+hashes, IDs, statuses and timestamps, never task/comment bodies or file contents.
+Expiry and eviction run on the next tracked read. See [configuration](docs/configuration.md)
+for storage details, disabling history and limits.
 
 ## Documentation
 

package/dist/api-client.js

@@ -1,7 +1,7 @@
 import { MooTeamError } from './errors.js';
 import { record } from './types.js';
 const API_BASE = 'https://api.moo.team/api';
-const READ_ROUTES = /^\/(?:tasks\/\d+|comments|user-profiles|task-statuses|projects\/\d+|activity-logs\/task\/\d+|files\/\d+)$/;
+const READ_ROUTES = /^\/(?:tasks(?:\/\d+)?|comments|user-profiles|task-statuses|projects(?:\/\d+)?|activity-logs\/task\/\d+|files\/\d+)$/;
 export class ApiClient {
     config;
     log;
@@ -21,10 +21,10 @@ export class ApiClient {
             throw new MooTeamError('INVALID_RESPONSE', 'Moo.team returned an invalid JSON response.');
         }
     }
-    async collection(path, params = {}) {
+    async collection(path, params = {}, maxPages = this.config.maxPages) {
         const result = { items: [], complete: false, total: null, pagesRead: 0, warnings: [] };
         const seen = new Set();
-        for (let page = 1; page <= this.config.maxPages; page++) {
+        for (let page = 1; page <= Math.min(maxPages, this.config.maxPages); page++) {
             let raw;
             try {
                 raw = await this.json(path, { ...params, page });
@@ -79,7 +79,7 @@ export class ApiClient {
                 result.warnings.push('Missing pagination metadata; completeness cannot be established.');
             return result;
         }
-        result.warnings.push(`Stopped at the configured limit of ${this.config.maxPages} pages.`);
+        result.warnings.push(`Stopped at the configured limit of ${Math.min(maxPages, this.config.maxPages)} pages.`);
         return result;
     }
     async file(fileId) {

package/dist/attachments.js

@@ -1,11 +1,12 @@
 import { Worker } from 'node:worker_threads';
 import { MooTeamError } from './errors.js';
+import { extractDocument } from './documents.js';
 export class AttachmentService {
     context;
     constructor(context) {
         this.context = context;
     }
-    async read(task, fileId, maxCharacters = 50000, maxPages = 30) {
+    async read(task, fileId, maxCharacters = 50000, maxPages = 30, options = {}) {
         const context = await this.context.getContext(task, { commentsLimit: 1 });
         const attachment = context.attachments.find(f => f.fileId === fileId);
         if (!attachment)
@@ -15,29 +16,40 @@ export class AttachmentService {
         const { bytes, mimeType } = await this.context.api.file(fileId);
         this.context.api.log('debug', 'attachment.loaded', { fileId, bytes: bytes.length, mimeType });
         const base = { attachment, downloadedBytes: bytes.length, mimeType };
+        const isPdf = Buffer.from(bytes.subarray(0, 5)).toString('ascii') === '%PDF-';
+        const isZip = bytes[0] === 0x50 && bytes[1] === 0x4b && [[3, 4], [5, 6], [7, 8]].some(([a, b]) => bytes[2] === a && bytes[3] === b);
+        if (options.pdfPages && !isPdf)
+            throw new MooTeamError('UNSUPPORTED_FORMAT', 'Page rendering is supported only for PDF attachments.');
+        if (options.archiveMember && !isZip)
+            throw new MooTeamError('UNSUPPORTED_FORMAT', 'Member selection requires a ZIP attachment.');
         const imageMime = imageType(bytes);
         if (imageMime) {
             if (bytes.length > 5 * 1024 * 1024)
                 throw new MooTeamError('IMAGE_OUTPUT_LIMIT', 'This image exceeds the 5 MiB image output limit. Its contents have not been returned.');
             return { ...base, kind: 'image', imageMime, data: Buffer.from(bytes).toString('base64'), complete: true };
         }
-        if (Buffer.from(bytes.subarray(0, 5)).toString('ascii') === '%PDF-') {
-            const pdf = await extractPdf(bytes, maxPages, maxCharacters, this.context.api.config.timeoutMs);
+        if (isPdf) {
+            const pdf = await extractPdf(bytes, maxPages, maxCharacters, this.context.api.config.timeoutMs, options.pdfPages);
+            if (options.pdfPages)
+                return { ...base, kind: 'pdf-pages', ...pdf, complete: !pdf.truncated, warnings: ['Selected PDF pages rendered in memory for visual inspection; this is not an OCR transcript or the whole document.', 'PDF.js may omit unsupported features or source images above 16 million pixels.'] };
             return { ...base, kind: 'pdf', ...pdf, complete: !pdf.truncated, warnings: pdf.textFound ? ['PDF text extraction does not include diagrams, image content or OCR.'] : ['No embedded text found. This PDF may require OCR or visual inspection.'] };
         }
+        if (isZip)
+            return { ...base, ...await extractDocument(bytes, { maxCharacters, maxPages, archiveMember: options.archiveMember }, this.context.api.config.timeoutMs) };
         if (mimeType.startsWith('text/') || /(?:json|xml|yaml|javascript)/.test(mimeType) || /\.(txt|md|csv|tsv|json|xml|yaml|yml|log|js|ts|css|html|sql|py|php)$/i.test(attachment.name)) {
             let text;
+            const encoding = options.encoding && options.encoding !== 'auto' ? options.encoding : bytes[0] === 255 && bytes[1] === 254 ? 'utf-16le' : bytes[0] === 254 && bytes[1] === 255 ? 'utf-16be' : 'utf-8';
             try {
-                text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+                text = new TextDecoder(encoding, { fatal: true }).decode(bytes);
             }
             catch {
-                throw new MooTeamError('UNSUPPORTED_ENCODING', 'This file is not valid UTF-8 text. Its contents were not decoded.');
+                throw new MooTeamError('UNSUPPORTED_ENCODING', 'Text decoding failed. Use an explicit supported encoding if this is not UTF-8 or BOM-marked UTF-16.');
             }
             if (text.includes('\0'))
                 throw new MooTeamError('UNSUPPORTED_FORMAT', 'The file contains binary data and cannot be treated as text.');
-            return { ...base, kind: 'text', text: text.slice(0, maxCharacters), totalCharacters: text.length, complete: text.length <= maxCharacters };
+            return { ...base, kind: 'text', text: text.slice(0, maxCharacters), encoding, totalCharacters: text.length, complete: text.length <= maxCharacters };
         }
-        return { ...base, kind: 'unsupported', complete: false, message: 'This version reads PNG/JPEG/WebP/GIF images, PDF embedded text and UTF-8 text files. Other files are identified but their contents are not extracted.' };
+        return { ...base, kind: 'unsupported', complete: false, message: 'Supported: images, PDF text/page images, DOCX/XLSX/PPTX text, ZIP inventory/member text and supported text encodings. Legacy DOC/XLS/PPT, other archives, audio and video are not extracted.' };
     }
 }
 function imageType(bytes) {
@@ -52,23 +64,27 @@ function imageType(bytes) {
         return 'image/webp';
     return null;
 }
-export function extractPdf(bytes, maxPages, maxCharacters, timeoutMs) {
+export function extractPdf(bytes, maxPages, maxCharacters, timeoutMs, pdfPages) {
+    if (pdfPages && (pdfPages.length < 1 || pdfPages.length > 5 || pdfPages.some(p => !Number.isSafeInteger(p) || p < 1)))
+        return Promise.reject(new MooTeamError('INVALID_PDF_PAGES', 'Select 1 to 5 positive PDF page numbers.'));
     return new Promise((resolve, reject) => {
-        const worker = new Worker(new URL('./pdf-worker.js', import.meta.url), { workerData: { bytes, maxPages, maxCharacters }, resourceLimits: { maxOldGenerationSizeMb: 256 }, stdout: true, stderr: true });
+        let finished = false;
+        const worker = new Worker(new URL('./pdf-worker.js', import.meta.url), { workerData: { bytes, maxPages, maxCharacters, pdfPages }, resourceLimits: { maxOldGenerationSizeMb: 256 }, stdout: true, stderr: true });
         // Parser output is isolated from MCP stdout and may contain document data, so do not forward it.
         worker.stdout.resume();
         worker.stderr.resume();
-        const timeout = setTimeout(() => { void worker.terminate(); reject(new MooTeamError('PDF_TIMEOUT', 'PDF extraction exceeded the configured timeout.')); }, timeoutMs);
+        const timeout = setTimeout(() => { finished = true; void worker.terminate(); reject(new MooTeamError('PDF_TIMEOUT', 'PDF extraction exceeded the configured timeout.')); }, timeoutMs);
         worker.once('message', (result) => {
+            finished = true;
             clearTimeout(timeout);
             void worker.terminate();
             if (result.error)
-                reject(new MooTeamError('PDF_EXTRACTION_FAILED', 'Could not extract text from this PDF; it may be encrypted or unsupported.'));
+                reject(new MooTeamError('PDF_EXTRACTION_FAILED', 'Could not read this PDF or selected pages; check page numbers, encryption and rendering limits.'));
             else
                 resolve(result);
         });
-        worker.once('error', () => { clearTimeout(timeout); reject(new MooTeamError('PDF_EXTRACTION_FAILED', 'The PDF parser failed.')); });
-        worker.once('exit', code => { clearTimeout(timeout); if (code !== 0)
+        worker.once('error', () => { finished = true; clearTimeout(timeout); reject(new MooTeamError('PDF_EXTRACTION_FAILED', 'The PDF parser failed.')); });
+        worker.once('exit', () => { clearTimeout(timeout); if (!finished)
             reject(new MooTeamError('PDF_EXTRACTION_FAILED', 'The PDF parser exited before completing.')); });
     });
 }

package/dist/config.js

@@ -1,6 +1,7 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { createHash } from 'node:crypto';
 import { MooTeamError } from './errors.js';
 export const defaultConfigPath = () => join(homedir(), '.config', 'mooteam-mcp', 'config.json');
 export function loadConfig(env = process.env) {
@@ -32,7 +33,8 @@ export function loadConfig(env = process.env) {
     if (!['debug', 'info', 'warn', 'error', 'silent'].includes(logLevel))
         throw new MooTeamError('CONFIG_INVALID', 'LOG_LEVEL must be debug, info, warn, error or silent.');
     const rolesFile = env.MOOTEAM_ROLES_FILE || join(dirname(path), 'roles.json');
-    return { token, company, fileToken, rolesFile, timeoutMs: integer(env.MOOTEAM_TIMEOUT_MS, 30000, 1000, 120000), maxPages: integer(env.MOOTEAM_MAX_PAGES, 100, 1, 1000), maxAttachmentBytes: integer(env.MOOTEAM_MAX_ATTACHMENT_BYTES, 10 * 1024 * 1024, 1024, 50 * 1024 * 1024), logLevel: logLevel };
+    const historyFile = env.MOOTEAM_HISTORY === 'off' ? undefined : join(dirname(path), `history-${createHash('sha256').update(company).digest('hex').slice(0, 16)}.json.gz`);
+    return { token, company, fileToken, rolesFile, historyFile, historyMaxBytes: integer(env.MOOTEAM_HISTORY_MAX_BYTES, 1048576, 16384, 10485760), historyMaxTasks: integer(env.MOOTEAM_HISTORY_MAX_TASKS, 200, 1, 2000), historyRetentionDays: integer(env.MOOTEAM_HISTORY_DAYS, 90, 1, 365), timeoutMs: integer(env.MOOTEAM_TIMEOUT_MS, 30000, 1000, 120000), maxPages: integer(env.MOOTEAM_MAX_PAGES, 100, 1, 1000), maxAttachmentBytes: integer(env.MOOTEAM_MAX_ATTACHMENT_BYTES, 10 * 1024 * 1024, 1024, 50 * 1024 * 1024), logLevel: logLevel };
 }
 function integer(value, fallback, min, max) {
     if (value === undefined)

package/dist/document-worker.js

@@ -0,0 +1,201 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { posix } from 'node:path';
+import { fromBuffer } from 'yauzl';
+import { SaxesParser } from 'saxes';
+const children = (node) => node.children.filter((n) => typeof n !== 'string');
+const all = (node, name) => [...(node.name === name ? [node] : []), ...children(node).flatMap(n => all(n, name))];
+const text = (node) => node?.children.map(n => typeof n === 'string' ? n : text(n)).join('') ?? '';
+function xml(bytes) {
+    const source = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    if (/<!DOCTYPE|<!ENTITY/i.test(source))
+        throw new Error('DTD unsupported');
+    const root = { name: '#document', attrs: {}, children: [] }, stack = [root];
+    let nodes = 0;
+    const parser = new SaxesParser({ xmlns: true });
+    parser.on('opentag', tag => {
+        if (++nodes > 100000 || stack.length > 128)
+            throw new Error('XML limit');
+        const node = { name: tag.local, attrs: {}, children: [] };
+        for (const attr of Object.values(tag.attributes))
+            if (typeof attr !== 'string')
+                node.attrs[attr.uri.endsWith('/relationships') ? `r:${attr.local}` : attr.local] = attr.value;
+        stack.at(-1).children.push(node);
+        stack.push(node);
+    });
+    parser.on('text', value => stack.at(-1).children.push(value));
+    parser.on('cdata', value => stack.at(-1).children.push(value));
+    parser.on('closetag', () => { stack.pop(); });
+    parser.write(source).close();
+    return root;
+}
+async function main() {
+    const zip = await new Promise((resolve, reject) => fromBuffer(Buffer.from(workerData.bytes), { lazyEntries: true, autoClose: false, validateEntrySizes: true }, (error, z) => error ? reject(error) : resolve(z)));
+    try {
+        const entries = new Map();
+        let inventoryComplete = true;
+        await new Promise((resolve, reject) => {
+            zip.once('error', reject);
+            zip.once('end', resolve);
+            zip.on('entry', entry => {
+                if (entries.size >= 1000) {
+                    inventoryComplete = false;
+                    resolve();
+                    return;
+                }
+                if (entries.has(entry.fileName)) {
+                    reject(new Error('Duplicate ZIP path'));
+                    return;
+                }
+                entries.set(entry.fileName, entry);
+                zip.readEntry();
+            });
+            zip.readEntry();
+        });
+        let inflated = 0;
+        const read = async (name) => {
+            const entry = entries.get(name);
+            if (!entry || entry.isEncrypted() || entry.uncompressedSize > 8 * 1024 * 1024)
+                throw new Error('Invalid ZIP member');
+            return new Promise((resolve, reject) => zip.openReadStream(entry, (error, stream) => {
+                if (error || !stream) {
+                    reject(error);
+                    return;
+                }
+                const chunks = [];
+                let size = 0;
+                stream.on('data', chunk => {
+                    size += chunk.length;
+                    inflated += chunk.length;
+                    if (size > 8 * 1024 * 1024 || inflated > 24 * 1024 * 1024) {
+                        stream.destroy(new Error('Inflation limit'));
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                stream.once('error', reject);
+                stream.once('end', () => resolve(Buffer.concat(chunks)));
+            }));
+        };
+        const warnings = [];
+        let output = '', truncated = false;
+        const emit = (value) => {
+            const room = workerData.maxCharacters - output.length;
+            output += value.slice(0, Math.max(0, room));
+            if (value.length > room)
+                truncated = true;
+        };
+        const relationships = async (part) => {
+            const path = posix.join(posix.dirname(part), '_rels', posix.basename(part) + '.rels');
+            const map = new Map();
+            if (!entries.has(path))
+                return map;
+            for (const r of all(xml(await read(path)), 'Relationship')) {
+                if (r.attrs.TargetMode === 'External')
+                    continue;
+                const target = r.attrs.Target ?? '';
+                if (!target || target.includes('\\') || /^[a-z]+:/i.test(target))
+                    throw new Error('Invalid relationship');
+                const resolved = target.startsWith('/') ? target.slice(1) : posix.normalize(posix.join(posix.dirname(part), target));
+                if (resolved.startsWith('../'))
+                    throw new Error('Relationship escapes archive');
+                map.set(r.attrs.Id, resolved);
+            }
+            return map;
+        };
+        if (workerData.archiveMember) {
+            const name = String(workerData.archiveMember);
+            if (!/\.(txt|md|csv|tsv|json|xml|yaml|yml|log|js|ts|css|html|sql|py|php)$/i.test(name))
+                throw new Error('Only text archive members can be read');
+            const source = new TextDecoder('utf-8', { fatal: true }).decode(await read(name));
+            if (source.includes('\0'))
+                throw new Error('Binary archive member');
+            emit(source);
+            return { kind: 'zip', text: output, complete: !truncated, warnings: ['Only the selected UTF-8 text member was read. Nested archives and external links were not opened.'] };
+        }
+        const kind = entries.has('word/document.xml') ? 'docx' : entries.has('xl/workbook.xml') ? 'xlsx' : entries.has('ppt/presentation.xml') ? 'pptx' : 'zip';
+        if (kind === 'zip')
+            return { kind, entries: [...entries.values()].map(e => ({ name: e.fileName, sizeBytes: e.uncompressedSize, compressedBytes: e.compressedSize, encrypted: e.isEncrypted() })), complete: inventoryComplete, warnings: [inventoryComplete ? 'Archive inventory only; member contents were not read.' : 'Archive inventory stopped after 1000 entries.'] };
+        if (!inventoryComplete)
+            throw new Error('Office archive entry limit');
+        if (kind === 'docx') {
+            const render = (n) => {
+                if (n.name === 'del')
+                    return '~~' + children(n).map(render).join('') + '~~';
+                if (n.name === 't' || n.name === 'delText')
+                    return text(n);
+                if (n.name === 'tab')
+                    return '\t';
+                if (n.name === 'br' || n.name === 'cr')
+                    return '\n';
+                const inner = children(n).map(render).join('');
+                return inner + (['p', 'tr'].includes(n.name) ? '\n' : n.name === 'tc' ? '\t' : '');
+            };
+            emit(render(xml(await read('word/document.xml'))));
+            for (const name of [...entries.keys()].filter(n => /^word\/(header\d+|footer\d+|footnotes|endnotes)\.xml$/.test(n))) {
+                if (truncated)
+                    break;
+                emit(`\n[${name}]\n` + render(xml(await read(name))));
+            }
+            warnings.push('Extracted document text, tables and notes; layout, drawings and embedded images were not interpreted. Deleted tracked text is struck through.');
+        }
+        else if (kind === 'xlsx') {
+            const workbook = xml(await read('xl/workbook.xml')), rels = await relationships('xl/workbook.xml');
+            const shared = entries.has('xl/sharedStrings.xml') ? all(xml(await read('xl/sharedStrings.xml')), 'si').map(si => all(si, 't').map(text).join('')) : [];
+            const sheets = all(workbook, 'sheet');
+            let cells = 0;
+            for (const sheet of sheets.slice(0, workerData.maxPages)) {
+                if (truncated)
+                    break;
+                const path = rels.get(sheet.attrs['r:id']);
+                if (!path)
+                    throw new Error('Missing sheet relation');
+                emit(`\n[Sheet: ${sheet.attrs.name ?? ''}]\n`);
+                for (const cell of all(xml(await read(path)), 'c')) {
+                    if (++cells > 10000) {
+                        truncated = true;
+                        break;
+                    }
+                    const raw = text(all(cell, 'v')[0]);
+                    let value = cell.attrs.t === 's' ? shared[Number(raw)] : cell.attrs.t === 'inlineStr' ? all(cell, 't').map(text).join('') : cell.attrs.t === 'b' ? (raw === '1' ? 'true' : 'false') : raw;
+                    if (value === undefined)
+                        throw new Error('Invalid shared string index');
+                    const formula = all(cell, 'f')[0];
+                    if (formula)
+                        value = `=${text(formula)} [cached: ${value}]`;
+                    emit(`${cell.attrs.r ?? '?'}\t${value}\n`);
+                    if (truncated)
+                        break;
+                }
+            }
+            if (sheets.length > workerData.maxPages)
+                truncated = true;
+            warnings.push('Formulas are never evaluated; cached values may be stale. Numbers/dates are raw stored values. Charts, formatting and images were not interpreted.');
+        }
+        else {
+            const presentation = xml(await read('ppt/presentation.xml')), rels = await relationships('ppt/presentation.xml');
+            const slides = all(presentation, 'sldId');
+            for (const [index, slide] of slides.slice(0, workerData.maxPages).entries()) {
+                if (truncated)
+                    break;
+                const path = rels.get(slide.attrs['r:id']);
+                if (!path)
+                    throw new Error('Missing slide relation');
+                const content = xml(await read(path));
+                emit(`\n[Slide ${index + 1}]\n` + all(content, 'p').map(p => all(p, 't').map(text).join('')).join('\n'));
+                for (const target of (await relationships(path)).values())
+                    if (/\/notesSlides\/notesSlide\d+\.xml$/.test(target))
+                        emit('\n[Speaker notes]\n' + all(xml(await read(target)), 'p').map(p => all(p, 't').map(text).join('')).join('\n'));
+            }
+            if (slides.length > workerData.maxPages)
+                truncated = true;
+            warnings.push('Slide text and speaker notes only; images, diagrams, animations and layout were not interpreted.');
+        }
+        if (truncated)
+            warnings.push('Output stopped at the requested character/page or cell limit.');
+        return { kind, text: output, complete: !truncated, warnings };
+    }
+    finally {
+        zip.close();
+    }
+}
+main().then(result => parentPort.postMessage(result), () => parentPort.postMessage({ error: true }));

package/dist/documents.js

@@ -0,0 +1,26 @@
+import { Worker } from 'node:worker_threads';
+import { MooTeamError } from './errors.js';
+export function extractDocument(bytes, options, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        const worker = new Worker(new URL('./document-worker.js', import.meta.url), { workerData: { bytes, ...options }, resourceLimits: { maxOldGenerationSizeMb: 256 }, stdout: true, stderr: true });
+        worker.stdout.resume();
+        worker.stderr.resume();
+        const done = (error, result) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            void worker.terminate();
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        const timer = setTimeout(() => done(new MooTeamError('DOCUMENT_TIMEOUT', 'Document extraction exceeded the configured timeout.')), timeoutMs);
+        worker.once('message', result => result.error ? done(new MooTeamError('DOCUMENT_EXTRACTION_FAILED', 'Document is corrupt, encrypted, unsupported, or exceeds parser limits.')) : done(undefined, result));
+        worker.once('error', () => done(new MooTeamError('DOCUMENT_EXTRACTION_FAILED', 'Document parser failed.')));
+        worker.once('exit', () => { if (!finished)
+            done(new MooTeamError('DOCUMENT_EXTRACTION_FAILED', 'Document parser exited before completing.')); });
+    });
+}

package/dist/history.js

@@ -0,0 +1,85 @@
+import { createHash } from 'node:crypto';
+import { gzipSync, gunzipSync } from 'node:zlib';
+import { z } from 'zod/v4';
+import { readLocalFile, withLocalLock, writeLocalFile } from './local-state.js';
+const hash = (v) => createHash('sha256').update(JSON.stringify(v) ?? 'null').digest('base64url').slice(0, 22);
+const canonicalText = (v) => ({ markdown: v.markdown, links: v.links, files: v.inlineFileIds, mentions: v.mentions.map((m) => m.userId) });
+const pairs = z.record(z.string(), z.string().length(22));
+const snapshotSchema = z.object({ at: z.string().datetime(), fields: pairs, comments: pairs, files: pairs, status: z.object({ status: z.string(), statusId: z.number().nullable() }) });
+const changesSchema = z.object({ at: z.string().datetime(), fields: z.array(z.string()), comments: z.object({ added: z.array(z.string()), edited: z.array(z.string()), noLongerVisible: z.array(z.string()) }), files: z.object({ added: z.array(z.string()), edited: z.array(z.string()), noLongerVisible: z.array(z.string()) }) });
+const stateSchema = z.object({ version: z.literal(1), company: z.string(), tasks: z.record(z.string(), z.object({ snapshot: snapshotSchema, events: z.array(changesSchema).max(20) })) });
+// Retain full current comments in RAM only, so returned windows do not affect comparisons.
+export const observations = new WeakMap();
+function snapshot(context) {
+    const observation = observations.get(context);
+    if (!observation)
+        throw new Error('Missing observation');
+    const t = context.task;
+    const fields = { title: t.title, description: canonicalText(t.description), status: t.status, workflowStatus: t.workflowStatus.statusId, assignee: t.assignee.userId, creator: t.creator.userId, coPerformer: t.coPerformer.userId, priority: t.priority, project: t.projectId, parent: t.parentTaskId, checklist: t.checklist, labels: t.labels.map((l) => l.labelId), startDate: t.startDate, endDate: t.endDate };
+    return { at: observation.at, fields: Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, hash(v)])), comments: Object.fromEntries(observation.comments.map(c => [String(c.commentId), hash([c.author.userId, c.parentId, c.replyToCommentId, canonicalText(c.body)])])), files: Object.fromEntries(context.attachments.map((f) => [`${f.source.kind}:${f.source.id}:${f.fileId}`, hash([f.name, f.sizeBytes, f.mimeType, f.createdAt, f.uploadedBy])])), status: { status: t.status, statusId: t.workflowStatus.statusId } };
+}
+function compare(a, b) {
+    return { added: Object.keys(b).filter(k => !(k in a)), edited: Object.keys(b).filter(k => k in a && a[k] !== b[k]), noLongerVisible: Object.keys(a).filter(k => !(k in b)) };
+}
+function compactChange(change) {
+    const compact = (values) => ({ added: values.added.slice(0, 100), edited: values.edited.slice(0, 100), noLongerVisible: values.noLongerVisible.slice(0, 100), counts: { added: values.added.length, edited: values.edited.length, noLongerVisible: values.noLongerVisible.length }, idsTruncated: Object.values(values).some(v => v.length > 100) });
+    return { ...change, comments: compact(change.comments), files: compact(change.files) };
+}
+export class HistoryService {
+    config;
+    log;
+    constructor(config, log) {
+        this.config = config;
+        this.log = log;
+    }
+    async observe(context) {
+        const base = { baselineUpdated: false, baselineCreated: false, warnings: [] };
+        if (!this.config.historyFile)
+            return { ...base, enabled: false };
+        if (!context.comments.sourceComplete)
+            return { ...base, enabled: true, warnings: ['Incomplete source: previous complete history baseline preserved.'] };
+        try {
+            return await withLocalLock(this.config.historyFile, async () => {
+                const maxBytes = this.config.historyMaxBytes ?? 1048576;
+                const bytes = await readLocalFile(this.config.historyFile, maxBytes);
+                const state = bytes ? stateSchema.parse(JSON.parse(gunzipSync(bytes, { maxOutputLength: 16 * 1024 * 1024 }).toString('utf8'))) : { version: 1, company: this.config.company, tasks: {} };
+                if (state.company !== this.config.company)
+                    throw new Error('Workspace mismatch');
+                const current = snapshot(context), key = String(context.task.taskId);
+                const cutoff = Date.now() - (this.config.historyRetentionDays ?? 90) * 86400000;
+                for (const [k, entry] of Object.entries(state.tasks))
+                    if (Date.parse(entry.snapshot.at) < cutoff)
+                        delete state.tasks[k];
+                const previous = state.tasks[key];
+                if (previous && previous.snapshot.at > current.at)
+                    return { ...base, enabled: true, warnings: ['A newer observation is already stored; this late read did not replace it.'] };
+                const changes = { at: current.at, fields: previous ? Object.keys(current.fields).filter(k => previous.snapshot.fields[k] !== current.fields[k]) : [], comments: compare(previous?.snapshot.comments ?? current.comments, current.comments), files: compare(previous?.snapshot.files ?? current.files, current.files) };
+                const changed = changes.fields.length || Object.values(changes.comments).some(v => v.length) || Object.values(changes.files).some(v => v.length);
+                const events = [...(previous?.events ?? []), ...(changed ? [changes] : [])].slice(-20);
+                state.tasks[key] = { snapshot: current, events };
+                const oldest = Object.keys(state.tasks).filter(k => k !== key).sort((a, b) => state.tasks[a].snapshot.at.localeCompare(state.tasks[b].snapshot.at));
+                let packed;
+                while (true) {
+                    const text = JSON.stringify(state);
+                    packed = gzipSync(text, { level: 9 });
+                    if (packed.length <= maxBytes && Buffer.byteLength(text) <= 16 * 1024 * 1024 && Object.keys(state.tasks).length <= (this.config.historyMaxTasks ?? 200))
+                        break;
+                    const evict = oldest.shift();
+                    if (evict)
+                        delete state.tasks[evict];
+                    else if (state.tasks[key].events.length)
+                        state.tasks[key].events.shift();
+                    else
+                        return { ...base, enabled: true, warnings: ['Task fingerprint exceeds the history storage budget; previous baseline preserved.'] };
+                }
+                await writeLocalFile(this.config.historyFile, packed);
+                this.log('debug', 'history.saved', { taskId: context.task.taskId, bytes: packed.length, tasks: Object.keys(state.tasks).length });
+                return { ...base, enabled: true, baselineUpdated: true, baselineCreated: !previous, previousReadAt: previous?.snapshot.at ?? null, currentReadAt: current.at, changed: Boolean(changed), changes: compactChange(changes), statusBefore: previous?.snapshot.status ?? null, statusNow: current.status, recentEvents: events.slice(-5).map(compactChange), storedBytes: packed.length };
+            });
+        }
+        catch {
+            this.log('warn', 'history.unavailable');
+            return { ...base, enabled: true, warnings: ['Local history could not be read or updated (busy, corrupt, or inaccessible). Task content is still available; history was preserved.'] };
+        }
+    }
+}

package/dist/local-state.js

@@ -0,0 +1,73 @@
+import { mkdir, open, rename, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { MooTeamError } from './errors.js';
+export async function readLocalFile(path, maxBytes) {
+    let file;
+    try {
+        file = await open(path, 'r');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    try {
+        const buffer = Buffer.alloc(maxBytes + 1);
+        let length = 0;
+        while (length < buffer.length) {
+            const { bytesRead } = await file.read(buffer, length, buffer.length - length, null);
+            if (!bytesRead)
+                break;
+            length += bytesRead;
+        }
+        if (length > maxBytes)
+            throw new MooTeamError('LOCAL_STATE_LIMIT', 'Local state exceeds its configured size limit.');
+        return buffer.subarray(0, length);
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function withLocalLock(path, action) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    let lock;
+    for (let attempt = 0; attempt < 40; attempt++) {
+        try {
+            lock = await open(path + '.lock', 'wx', 0o600);
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            await new Promise(resolve => setTimeout(resolve, 50));
+        }
+    }
+    if (!lock)
+        throw new MooTeamError('LOCAL_STATE_BUSY', 'Local state is locked by another process. Retry; if a process crashed, remove its .lock file after stopping all MCP processes.');
+    try {
+        return await action();
+    }
+    finally {
+        await lock.close();
+        await unlink(path + '.lock');
+    }
+}
+/** Caller holds the lock. At most one bounded temporary copy exists. */
+export async function writeLocalFile(path, bytes) {
+    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        const file = await open(temp, 'wx', 0o600);
+        try {
+            await file.writeFile(bytes);
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        }
+        await rename(temp, path);
+    }
+    finally {
+        await unlink(temp).catch(() => { });
+    }
+}