monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/mcp-tools/task-tools.js

@@ -1,514 +0,0 @@
-/**
- * Task MCP Tools for CLI
- *
- * Tool definitions for task management with file persistence.
- */
-import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { randomBytes } from 'node:crypto';
-import { getMonomindDataRoot } from './types.js';
-// Storage paths — relative to the git-safe data root
-const TASK_DIR = 'tasks';
-const TASK_FILE = 'store.json';
-function getTaskDir() {
-    return join(getMonomindDataRoot(), TASK_DIR);
-}
-function getTaskPath() {
-    return join(getTaskDir(), TASK_FILE);
-}
-function ensureTaskDir() {
-    const dir = getTaskDir();
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-}
-const MAX_TASK_STORE_BYTES = 50 * 1024 * 1024;
-export function loadTaskStore() {
-    try {
-        const path = getTaskPath();
-        if (existsSync(path)) {
-            if (statSync(path).size > MAX_TASK_STORE_BYTES)
-                return { tasks: {}, version: '3.0.0' };
-            const data = readFileSync(path, 'utf-8');
-            const parsed = JSON.parse(data);
-            if (parsed && typeof parsed === 'object' && Object.prototype.hasOwnProperty.call(parsed, '__proto__'))
-                return { tasks: {}, version: '3.0.0' };
-            return parsed;
-        }
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[loadTaskStore] failed to read/parse task store:', e);
-    }
-    return { tasks: {}, version: '3.0.0' };
-}
-function saveTaskStore(store) {
-    ensureTaskDir();
-    const taskPath = getTaskPath();
-    // Unique tmp filename — concurrent task_assign/complete calls would
-    // otherwise race on the same .tmp file.
-    const tmpPath = `${taskPath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmpPath, JSON.stringify(store, null, 2), 'utf-8');
-    renameSync(tmpPath, taskPath);
-}
-const FORBIDDEN_TASK_IDS = new Set(['__proto__', 'constructor', 'prototype']);
-export const taskTools = [
-    {
-        name: 'task_create',
-        description: 'Create a new task',
-        category: 'task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                type: { type: 'string', description: 'Task type (feature, bugfix, research, refactor)' },
-                description: { type: 'string', description: 'Task description' },
-                priority: { type: 'string', description: 'Task priority (low, normal, high, critical)' },
-                assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
-                tags: { type: 'array', items: { type: 'string' }, description: 'Task tags' },
-            },
-            required: ['type', 'description'],
-        },
-        handler: async (input) => {
-            const store = loadTaskStore();
-            const taskId = `task-${Date.now()}-${randomBytes(4).toString('hex')}`;
-            // Cap all string fields: they are persisted verbatim to the task JSON store.
-            const MAX_TASK_TYPE_LEN = 128;
-            const MAX_TASK_DESC_LEN = 64 * 1024; // 64 KB — realistic task descriptions
-            const MAX_TASK_ASSIGNEE_LEN = 256;
-            const MAX_TASK_ASSIGNEES = 100;
-            const MAX_TASK_TAG_LEN = 128;
-            const MAX_TASK_TAGS = 50;
-            const rawTaskType = input.type;
-            const taskType = typeof rawTaskType === 'string' && rawTaskType.length > MAX_TASK_TYPE_LEN
-                ? rawTaskType.slice(0, MAX_TASK_TYPE_LEN) : rawTaskType;
-            const rawTaskDesc = input.description;
-            const taskDesc = typeof rawTaskDesc === 'string' && rawTaskDesc.length > MAX_TASK_DESC_LEN
-                ? rawTaskDesc.slice(0, MAX_TASK_DESC_LEN) : rawTaskDesc;
-            const rawAssignTo = input.assignTo || [];
-            const assignedTo = Array.isArray(rawAssignTo)
-                ? rawAssignTo.slice(0, MAX_TASK_ASSIGNEES).map(a => typeof a === 'string' && a.length > MAX_TASK_ASSIGNEE_LEN ? a.slice(0, MAX_TASK_ASSIGNEE_LEN) : a)
-                : [];
-            const rawTags = input.tags || [];
-            const tags = Array.isArray(rawTags)
-                ? rawTags.slice(0, MAX_TASK_TAGS).map(t => typeof t === 'string' && t.length > MAX_TASK_TAG_LEN ? t.slice(0, MAX_TASK_TAG_LEN) : t)
-                : [];
-            const task = {
-                taskId,
-                type: taskType,
-                description: taskDesc,
-                priority: input.priority || 'normal',
-                status: 'pending',
-                progress: 0,
-                assignedTo,
-                tags,
-                createdAt: new Date().toISOString(),
-                startedAt: null,
-                completedAt: null,
-            };
-            store.tasks[taskId] = task;
-            saveTaskStore(store);
-            return {
-                taskId,
-                type: task.type,
-                description: task.description,
-                priority: task.priority,
-                status: task.status,
-                createdAt: task.createdAt,
-                assignedTo: task.assignedTo,
-                tags: task.tags,
-            };
-        },
-    },
-    {
-        name: 'task_status',
-        description: 'Get task status',
-        category: 'task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                taskId: { type: 'string', description: 'Task ID' },
-            },
-            required: ['taskId'],
-        },
-        handler: async (input) => {
-            const store = loadTaskStore();
-            const taskId = input.taskId;
-            if (FORBIDDEN_TASK_IDS.has(taskId))
-                return { taskId, status: 'not_found', error: 'Task not found' };
-            const task = store.tasks[taskId];
-            if (task) {
-                return {
-                    taskId: task.taskId,
-                    type: task.type,
-                    description: task.description,
-                    status: task.status,
-                    progress: task.progress,
-                    priority: task.priority,
-                    assignedTo: task.assignedTo,
-                    tags: task.tags,
-                    createdAt: task.createdAt,
-                    startedAt: task.startedAt,
-                    completedAt: task.completedAt,
-                    result: task.result || null,
-                };
-            }
-            return {
-                taskId,
-                status: 'not_found',
-                error: 'Task not found',
-            };
-        },
-    },
-    {
-        name: 'task_list',
-        description: 'List all tasks',
-        category: 'task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                status: { type: 'string', description: 'Filter by status' },
-                type: { type: 'string', description: 'Filter by type' },
-                assignedTo: { type: 'string', description: 'Filter by assigned agent' },
-                priority: { type: 'string', description: 'Filter by priority' },
-                limit: { type: 'number', description: 'Max tasks to return' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadTaskStore();
-            let tasks = Object.values(store.tasks);
-            // Apply filters
-            // 'all' is a sentinel meaning "do not filter", not a status any task has.
-            // Without this, `task list --all` and `monomind status tasks` — both of
-            // which pass status:'all' — matched nothing and reported an empty store
-            // while tasks existed on disk.
-            if (input.status && input.status !== 'all') {
-                // Support comma-separated status values
-                const statuses = input.status.split(',').map(s => s.trim()).filter(s => s !== 'all');
-                if (statuses.length > 0)
-                    tasks = tasks.filter(t => statuses.includes(t.status));
-            }
-            if (input.type) {
-                tasks = tasks.filter(t => t.type === input.type);
-            }
-            if (input.assignedTo) {
-                tasks = tasks.filter(t => t.assignedTo.includes(input.assignedTo));
-            }
-            if (input.priority) {
-                tasks = tasks.filter(t => t.priority === input.priority);
-            }
-            // Sort by creation date (newest first)
-            tasks.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-            // Apply limit — cap to 1 000 to prevent returning the entire task store
-            // in one response, which could cause OOM on large deployments.
-            const MAX_TASK_LIMIT = 1_000;
-            const rawLimit = typeof input.limit === 'number' ? input.limit : 50;
-            const limit = Number.isFinite(rawLimit) && rawLimit > 0
-                ? Math.min(Math.floor(rawLimit), MAX_TASK_LIMIT)
-                : 50;
-            tasks = tasks.slice(0, limit);
-            return {
-                tasks: tasks.map(t => ({
-                    taskId: t.taskId,
-                    type: t.type,
-                    description: t.description,
-                    status: t.status,
-                    progress: t.progress,
-                    priority: t.priority,
-                    assignedTo: t.assignedTo,
-                    createdAt: t.createdAt,
-                })),
-                total: tasks.length,
-                filters: {
-                    status: input.status,
-                    type: input.type,
-                    assignedTo: input.assignedTo,
-                    priority: input.priority,
-                },
-            };
-        },
-    },
-    {
-        name: 'task_complete',
-        description: 'Mark task as complete',
-        category: 'task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                taskId: { type: 'string', description: 'Task ID' },
-                result: { type: 'object', description: 'Task result data' },
-            },
-            required: ['taskId'],
-        },
-        handler: async (input) => {
-            const store = loadTaskStore();
-            const taskId = input.taskId;
-            if (FORBIDDEN_TASK_IDS.has(taskId))
-                return { taskId, status: 'not_found', error: 'Task not found' };
-            const task = store.tasks[taskId];
-            if (task) {
-                task.status = 'completed';
-                task.progress = 100;
-                task.completedAt = new Date().toISOString();
-                task.result = input.result || {};
-                saveTaskStore(store);
-                // Sync assigned agents back to idle and increment taskCount
-                if (task.assignedTo.length > 0) {
-                    const agentStorePath = join(getMonomindDataRoot(), 'agents', 'store.json');
-                    try {
-                        let agentStore = { agents: {} };
-                        if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
-                            const agentRaw = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
-                            if (agentRaw && typeof agentRaw === 'object' && !Object.prototype.hasOwnProperty.call(agentRaw, '__proto__')) {
-                                agentStore = agentRaw;
-                            }
-                        }
-                        for (const agentId of task.assignedTo) {
-                            const FORBIDDEN_AGENT_IDS_TC = new Set(['__proto__', 'constructor', 'prototype']);
-                            if (typeof agentId === 'string' && agentId.length > 0 && agentId.length <= 128 &&
-                                !FORBIDDEN_AGENT_IDS_TC.has(agentId) && Object.hasOwn(agentStore.agents, agentId)) {
-                                agentStore.agents[agentId].status = 'idle';
-                                agentStore.agents[agentId].currentTask = null;
-                                agentStore.agents[agentId].taskCount =
-                                    (agentStore.agents[agentId].taskCount || 0) + 1;
-                            }
-                        }
-                        const agentDir = join(getMonomindDataRoot(), 'agents');
-                        if (!existsSync(agentDir))
-                            mkdirSync(agentDir, { recursive: true });
-                        const tmpAgent1 = `${agentStorePath}.${process.pid}.${Date.now()}.tmp`;
-                        writeFileSync(tmpAgent1, JSON.stringify(agentStore, null, 2), 'utf-8');
-                        renameSync(tmpAgent1, agentStorePath);
-                    }
-                    catch (e) {
-                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                            console.error('[task_complete] agent store sync failed:', e);
-                    }
-                }
-                return {
-                    taskId: task.taskId,
-                    status: task.status,
-                    completedAt: task.completedAt,
-                    result: task.result,
-                };
-            }
-            return {
-                taskId,
-                status: 'not_found',
-                error: 'Task not found',
-            };
-        },
-    },
-    {
-        name: 'task_update',
-        description: 'Update task status or progress',
-        category: 'task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                taskId: { type: 'string', description: 'Task ID' },
-                status: { type: 'string', description: 'New status' },
-                progress: { type: 'number', description: 'Progress percentage (0-100)' },
-                assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
-            },
-            required: ['taskId'],
-        },
-        handler: async (input) => {
-            const store = loadTaskStore();
-            const taskId = input.taskId;
-            if (FORBIDDEN_TASK_IDS.has(taskId))
-                return { success: false, taskId, error: 'Task not found' };
-            const task = store.tasks[taskId];
-            if (task) {
-                if (input.status) {
-                    const newStatus = input.status;
-                    task.status = newStatus;
-                    if (newStatus === 'in_progress' && !task.startedAt) {
-                        task.startedAt = new Date().toISOString();
-                    }
-                }
-                if (typeof input.progress === 'number') {
-                    task.progress = Math.min(100, Math.max(0, input.progress));
-                }
-                if (input.assignTo) {
-                    // Cap array and element lengths — task_create already does this;
-                    // task_update must apply the same guards so the on-disk store
-                    // cannot be inflated via the update path.
-                    const MAX_TASK_ASSIGNEE_LEN = 256;
-                    const MAX_TASK_ASSIGNEES = 100;
-                    const rawAssignTo = input.assignTo;
-                    task.assignedTo = Array.isArray(rawAssignTo)
-                        ? rawAssignTo.slice(0, MAX_TASK_ASSIGNEES).map(a => typeof a === 'string' && a.length > MAX_TASK_ASSIGNEE_LEN ? a.slice(0, MAX_TASK_ASSIGNEE_LEN) : a)
-                        : task.assignedTo;
-                }
-                saveTaskStore(store);
-                return {
-                    success: true,
-                    taskId: task.taskId,
-                    status: task.status,
-                    progress: task.progress,
-                    assignedTo: task.assignedTo,
-                };
-            }
-            return {
-                success: false,
-                taskId,
-                error: 'Task not found',
-            };
-        },
-    },
-    {
-        name: 'task_assign',
-        description: 'Assign a task to one or more agents',
-        category: 'task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                taskId: { type: 'string', description: 'Task ID to assign' },
-                agentIds: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
-                unassign: { type: 'boolean', description: 'Unassign all agents from task' },
-            },
-            required: ['taskId'],
-        },
-        handler: async (input) => {
-            const store = loadTaskStore();
-            const taskId = input.taskId;
-            if (FORBIDDEN_TASK_IDS.has(taskId))
-                return { taskId, error: 'Task not found' };
-            const task = store.tasks[taskId];
-            if (!task) {
-                return { taskId, error: 'Task not found' };
-            }
-            const previouslyAssigned = [...task.assignedTo];
-            // Load agent store to sync worker state. Distinguish "file doesn't
-            // exist yet" (safe to proceed with an empty store) from "file exists
-            // but failed to read/parse" (a real store that's momentarily corrupt
-            // or oversized) — the latter must NOT fall through to the unconditional
-            // write-back below, or a transient read failure silently wipes out
-            // every agent's real on-disk state.
-            const agentStorePath = join(getMonomindDataRoot(), 'agents', 'store.json');
-            let agentStore = { agents: {} };
-            let agentStoreReadFailed = false;
-            try {
-                if (existsSync(agentStorePath)) {
-                    if (statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
-                        agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
-                    }
-                    else {
-                        agentStoreReadFailed = true;
-                    }
-                }
-            }
-            catch (e) {
-                agentStoreReadFailed = true;
-                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                    console.error('[task_assign] failed to read agent store — skipping agent-store sync to avoid overwriting it with an empty one:', e);
-            }
-            // Reject IDs that would mutate Object.prototype when used as a key in
-            // the JSON-loaded plain object `agentStore.agents`.
-            const FORBIDDEN_AGENT_IDS = new Set(['__proto__', 'constructor', 'prototype']);
-            const isValidAgentId = (id) => typeof id === 'string' && id.length > 0 && id.length <= 128 && !FORBIDDEN_AGENT_IDS.has(id);
-            if (input.unassign) {
-                // Revert previously assigned agents to idle
-                for (const agentId of previouslyAssigned) {
-                    if (isValidAgentId(agentId) && Object.hasOwn(agentStore.agents, agentId)) {
-                        agentStore.agents[agentId].status = 'idle';
-                        agentStore.agents[agentId].currentTask = null;
-                    }
-                }
-                task.assignedTo = [];
-            }
-            else {
-                const rawIds = input.agentIds || [];
-                const agentIds = rawIds.filter(isValidAgentId);
-                // Revert old agents to idle
-                for (const agentId of previouslyAssigned) {
-                    if (isValidAgentId(agentId) && !agentIds.includes(agentId) && Object.hasOwn(agentStore.agents, agentId)) {
-                        agentStore.agents[agentId].status = 'idle';
-                        agentStore.agents[agentId].currentTask = null;
-                    }
-                }
-                // Set new agents to active
-                for (const agentId of agentIds) {
-                    if (Object.hasOwn(agentStore.agents, agentId)) {
-                        agentStore.agents[agentId].status = 'busy';
-                        agentStore.agents[agentId].currentTask = taskId;
-                    }
-                }
-                task.assignedTo = agentIds;
-                // Auto-transition task to in_progress if pending
-                if (task.status === 'pending' && agentIds.length > 0) {
-                    task.status = 'in_progress';
-                    if (!task.startedAt) {
-                        task.startedAt = new Date().toISOString();
-                    }
-                }
-            }
-            saveTaskStore(store);
-            // Save agent store — skipped when the read above failed, so a
-            // transient corrupt/oversized store.json is left alone instead of
-            // being overwritten with an empty one.
-            if (!agentStoreReadFailed) {
-                const agentDir = join(getMonomindDataRoot(), 'agents');
-                if (!existsSync(agentDir)) {
-                    mkdirSync(agentDir, { recursive: true });
-                }
-                const tmpAgent2 = `${agentStorePath}.${process.pid}.${Date.now()}.tmp`;
-                writeFileSync(tmpAgent2, JSON.stringify(agentStore, null, 2), 'utf-8');
-                renameSync(tmpAgent2, agentStorePath);
-            }
-            return {
-                taskId: task.taskId,
-                assignedTo: task.assignedTo,
-                previouslyAssigned,
-                status: task.status,
-                ...(agentStoreReadFailed ? { agentStoreSyncSkipped: true } : {}),
-            };
-        },
-    },
-    {
-        name: 'task_cancel',
-        description: 'Cancel a task',
-        category: 'task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                taskId: { type: 'string', description: 'Task ID' },
-                reason: { type: 'string', description: 'Cancellation reason' },
-            },
-            required: ['taskId'],
-        },
-        handler: async (input) => {
-            const store = loadTaskStore();
-            const taskId = input.taskId;
-            if (FORBIDDEN_TASK_IDS.has(taskId))
-                return { success: false, taskId, error: 'Task not found' };
-            const task = store.tasks[taskId];
-            if (task) {
-                task.status = 'cancelled';
-                task.completedAt = new Date().toISOString();
-                // Cap reason: persisted verbatim to the task store on disk.
-                // Without a cap an attacker can inflate the store with an arbitrarily
-                // large cancellation reason string.
-                const MAX_CANCEL_REASON_LEN = 1024;
-                const rawReason = input.reason;
-                const cancelReason = typeof rawReason === 'string' && rawReason.length > MAX_CANCEL_REASON_LEN
-                    ? rawReason.slice(0, MAX_CANCEL_REASON_LEN)
-                    : (rawReason || 'Cancelled by user');
-                task.result = { cancelReason };
-                saveTaskStore(store);
-                return {
-                    success: true,
-                    taskId: task.taskId,
-                    status: task.status,
-                    cancelledAt: task.completedAt,
-                };
-            }
-            return {
-                success: false,
-                taskId,
-                error: 'Task not found',
-            };
-        },
-    },
-];
-//# sourceMappingURL=task-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/terminal-tools.d.ts

@@ -1,10 +0,0 @@
-/**
- * Terminal MCP Tools for CLI
- *
- * Terminal session management with real command execution.
- */
-import type { MCPTool } from './types.js';
-/** Returns a copy of `env` with secret-shaped variable names removed. */
-export declare function filterSecretEnvVars(env: NodeJS.ProcessEnv): Record<string, string>;
-export declare const terminalTools: MCPTool[];
-//# sourceMappingURL=terminal-tools.d.ts.map