@dalmasonto/taskflow-mcp 1.0.33 → 2.0.0

package/dist/tools/tasks.js

@@ -1,403 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { logActivity, errorResponse, successResponse, now, broadcastChange } from '../helpers.js';
-import { TaskStatus, TaskPriority, LinkSchema, VALID_TRANSITIONS } from '../types.js';
-function parseTask(row) {
-    return {
-        ...row,
-        dependencies: JSON.parse(row.dependencies),
-        links: JSON.parse(row.links),
-        tags: JSON.parse(row.tags),
-    };
-}
-/** Compact task for list/search responses — omits description, null fields, and empty arrays */
-function parseTaskCompact(row) {
-    const tags = JSON.parse(row.tags);
-    const deps = JSON.parse(row.dependencies);
-    const result = {
-        id: row.id,
-        title: row.title,
-        status: row.status,
-        priority: row.priority,
-    };
-    if (row.project_id != null)
-        result.project_id = row.project_id;
-    if (tags.length > 0)
-        result.tags = tags;
-    if (deps.length > 0)
-        result.dependencies = deps;
-    if (row.due_date != null)
-        result.due_date = row.due_date;
-    if (row.estimated_time != null)
-        result.estimated_time = row.estimated_time;
-    return result;
-}
-function detectCycle(taskId, proposedDeps) {
-    const db = getDb();
-    const allTasks = db.prepare('SELECT id, dependencies FROM tasks').all();
-    // Build adjacency list: task -> its dependencies (task depends on dep means edge task->dep)
-    // A cycle means: taskId depends on X which depends on Y ... which depends on taskId
-    // We need to check: from any of proposedDeps, can we reach taskId by following dependencies?
-    // Actually, the direction matters. If task A depends on B, it means B must be done before A.
-    // A cycle: A depends on B, B depends on A.
-    // Adjacency: A -> [B], B -> [A]. Starting from A's deps [B], follow B's deps [A], found A = cycle.
-    const adj = new Map();
-    for (const t of allTasks) {
-        const deps = JSON.parse(t.dependencies);
-        if (t.id === taskId) {
-            // Use proposed deps instead of current
-            adj.set(t.id, proposedDeps);
-        }
-        else {
-            adj.set(t.id, deps);
-        }
-    }
-    // If task doesn't exist yet (create), add it
-    if (!adj.has(taskId)) {
-        adj.set(taskId, proposedDeps);
-    }
-    // DFS from taskId following dependency edges to see if we return to taskId
-    const visited = new Set();
-    const inStack = new Set();
-    function dfs(node) {
-        if (inStack.has(node))
-            return true; // back-edge = cycle
-        if (visited.has(node))
-            return false;
-        visited.add(node);
-        inStack.add(node);
-        const deps = adj.get(node) || [];
-        for (const dep of deps) {
-            if (dfs(dep))
-                return true;
-        }
-        inStack.delete(node);
-        return false;
-    }
-    return dfs(taskId);
-}
-// ─── exported handler functions ───────────────────────────────────────
-export async function createTask(params) {
-    const db = getDb();
-    const { title, description, status = 'not_started', priority = 'medium', project_id, dependencies = [], tags = [], links = [], due_date, estimated_time, } = params;
-    // Validate project_id
-    if (project_id != null) {
-        const proj = db.prepare('SELECT id FROM projects WHERE id = ?').get(project_id);
-        if (!proj)
-            return errorResponse('Project not found', 'NOT_FOUND');
-    }
-    // Validate dependencies exist
-    if (dependencies.length > 0) {
-        const placeholders = dependencies.map(() => '?').join(',');
-        const existing = db.prepare(`SELECT id FROM tasks WHERE id IN (${placeholders})`).all(...dependencies);
-        if (existing.length !== dependencies.length) {
-            return errorResponse('One or more dependency task IDs do not exist', 'VALIDATION_ERROR');
-        }
-    }
-    // Check for cycles — we need a temporary ID; use max(id)+1 as placeholder
-    if (dependencies.length > 0) {
-        const maxRow = db.prepare('SELECT COALESCE(MAX(id), 0) + 1 AS next_id FROM tasks').get();
-        if (detectCycle(maxRow.next_id, dependencies)) {
-            return errorResponse('Adding these dependencies would create a cycle', 'CYCLE_DETECTED');
-        }
-    }
-    const ts = now();
-    const result = db.prepare(`INSERT INTO tasks (title, description, status, priority, project_id, dependencies, links, tags, due_date, estimated_time, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(title, description ?? null, status, priority, project_id ?? null, JSON.stringify(dependencies), JSON.stringify(links), JSON.stringify(tags), due_date ?? null, estimated_time ?? null, ts, ts);
-    const task = db.prepare('SELECT * FROM tasks WHERE id = ?').get(result.lastInsertRowid);
-    logActivity('task_created', title, { entityType: 'task', entityId: task.id });
-    const createdTask = parseTask(task);
-    broadcastChange('task', 'task_created', createdTask);
-    return successResponse(createdTask);
-}
-export async function listTasks(params) {
-    const db = getDb();
-    const conditions = [];
-    const values = [];
-    if (params.status) {
-        conditions.push('status = ?');
-        values.push(params.status);
-    }
-    if (params.project_id != null) {
-        conditions.push('project_id = ?');
-        values.push(params.project_id);
-    }
-    if (params.priority) {
-        conditions.push('priority = ?');
-        values.push(params.priority);
-    }
-    let sql = 'SELECT * FROM tasks';
-    if (conditions.length > 0) {
-        sql += ' WHERE ' + conditions.join(' AND ');
-    }
-    let rows = db.prepare(sql).all(...values);
-    // Filter by tag in-memory (JSON column)
-    if (params.tag) {
-        rows = rows.filter(r => {
-            const tags = JSON.parse(r.tags);
-            return tags.includes(params.tag);
-        });
-    }
-    return successResponse(rows.map(parseTaskCompact));
-}
-export async function getTask(params) {
-    const db = getDb();
-    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
-    if (!row)
-        return errorResponse('Task not found', 'NOT_FOUND');
-    const timeRow = db.prepare(`SELECT
-       COUNT(*) AS session_count,
-       COALESCE(SUM((julianday(COALESCE(end, datetime('now'))) - julianday(start)) * 86400000), 0) AS total_time
-     FROM sessions WHERE task_id = ?`).get(params.id);
-    return successResponse({
-        ...parseTask(row),
-        total_time: Math.round(timeRow.total_time),
-        session_count: timeRow.session_count,
-    });
-}
-export async function updateTask(params) {
-    const db = getDb();
-    const old = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
-    if (!old)
-        return errorResponse('Task not found', 'NOT_FOUND');
-    const oldParsed = parseTask(old);
-    // Validate dependencies
-    const newDeps = params.dependencies ?? oldParsed.dependencies;
-    if (params.dependencies && params.dependencies.length > 0) {
-        const placeholders = params.dependencies.map(() => '?').join(',');
-        const existing = db.prepare(`SELECT id FROM tasks WHERE id IN (${placeholders})`).all(...params.dependencies);
-        if (existing.length !== params.dependencies.length) {
-            return errorResponse('One or more dependency task IDs do not exist', 'VALIDATION_ERROR');
-        }
-        // Cycle detection
-        if (detectCycle(params.id, params.dependencies)) {
-            return errorResponse('Adding these dependencies would create a cycle', 'CYCLE_DETECTED');
-        }
-    }
-    // Validate project_id if changing
-    if (params.project_id != null) {
-        const proj = db.prepare('SELECT id FROM projects WHERE id = ?').get(params.project_id);
-        if (!proj)
-            return errorResponse('Project not found', 'NOT_FOUND');
-    }
-    const ts = now();
-    const updates = {};
-    if (params.title !== undefined)
-        updates.title = params.title;
-    if (params.description !== undefined)
-        updates.description = params.description;
-    if (params.status !== undefined)
-        updates.status = params.status;
-    if (params.priority !== undefined)
-        updates.priority = params.priority;
-    if (params.project_id !== undefined)
-        updates.project_id = params.project_id;
-    if (params.dependencies !== undefined)
-        updates.dependencies = JSON.stringify(params.dependencies);
-    if (params.tags !== undefined)
-        updates.tags = JSON.stringify(params.tags);
-    if (params.links !== undefined)
-        updates.links = JSON.stringify(params.links);
-    if (params.due_date !== undefined)
-        updates.due_date = params.due_date;
-    if (params.estimated_time !== undefined)
-        updates.estimated_time = params.estimated_time;
-    if (params.allowed_tools !== undefined)
-        updates.allowed_tools = JSON.stringify(params.allowed_tools);
-    if (params.denied_tools !== undefined)
-        updates.denied_tools = JSON.stringify(params.denied_tools);
-    if (Object.keys(updates).length === 0) {
-        return successResponse(oldParsed);
-    }
-    updates.updated_at = ts;
-    const setClauses = Object.keys(updates).map(k => `${k} = ?`).join(', ');
-    const vals = Object.values(updates);
-    db.prepare(`UPDATE tasks SET ${setClauses} WHERE id = ?`).run(...vals, params.id);
-    // Log granular changes for deps, tags, links
-    if (params.dependencies !== undefined) {
-        const added = params.dependencies.filter(d => !oldParsed.dependencies.includes(d));
-        const removed = oldParsed.dependencies.filter(d => !params.dependencies.includes(d));
-        for (const d of added) {
-            logActivity('dependency_added', oldParsed.title, { detail: `Dependency ${d} added`, entityType: 'task', entityId: params.id });
-        }
-        for (const d of removed) {
-            logActivity('dependency_removed', oldParsed.title, { detail: `Dependency ${d} removed`, entityType: 'task', entityId: params.id });
-        }
-    }
-    if (params.tags !== undefined) {
-        const added = params.tags.filter(t => !oldParsed.tags.includes(t));
-        const removed = oldParsed.tags.filter(t => !params.tags.includes(t));
-        for (const t of added) {
-            logActivity('tag_added', oldParsed.title, { detail: `Tag "${t}" added`, entityType: 'task', entityId: params.id });
-        }
-        for (const t of removed) {
-            logActivity('tag_removed', oldParsed.title, { detail: `Tag "${t}" removed`, entityType: 'task', entityId: params.id });
-        }
-    }
-    if (params.links !== undefined) {
-        const oldUrls = new Set(oldParsed.links.map(l => l.url));
-        const newUrls = new Set(params.links.map(l => l.url));
-        const added = params.links.filter(l => !oldUrls.has(l.url));
-        const removed = oldParsed.links.filter(l => !newUrls.has(l.url));
-        for (const l of added) {
-            logActivity('link_added', oldParsed.title, { detail: `Link "${l.label}" added`, entityType: 'task', entityId: params.id });
-        }
-        for (const l of removed) {
-            logActivity('task_unlinked', oldParsed.title, { detail: `Link "${l.label}" removed`, entityType: 'task', entityId: params.id });
-        }
-    }
-    const updated = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
-    const updatedTask = parseTask(updated);
-    broadcastChange('task', 'task_updated', updatedTask);
-    return successResponse(updatedTask);
-}
-export async function updateTaskStatus(params) {
-    const db = getDb();
-    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
-    if (!row)
-        return errorResponse('Task not found', 'NOT_FOUND');
-    const currentStatus = row.status;
-    const allowed = VALID_TRANSITIONS[currentStatus];
-    if (!allowed || !allowed.includes(params.status)) {
-        return errorResponse(`Cannot transition from "${currentStatus}" to "${params.status}"`, 'INVALID_TRANSITION');
-    }
-    const ts = now();
-    // Auto-start a timer session when entering in_progress
-    if (params.status === 'in_progress') {
-        const existingOpen = db.prepare('SELECT id FROM sessions WHERE task_id = ? AND end IS NULL').get(params.id);
-        if (!existingOpen) {
-            const result = db.prepare('INSERT INTO sessions (task_id, start, end) VALUES (?, ?, ?)').run(params.id, ts, null);
-            const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(result.lastInsertRowid);
-            logActivity('timer_started', row.title, { entityType: 'task', entityId: params.id });
-            broadcastChange('timer', 'timer_started', { task_id: params.id, session, task_status: 'in_progress' });
-        }
-    }
-    // Auto-close any active timer session when leaving an active state
-    const terminalStatuses = ['done', 'partial_done', 'blocked', 'paused'];
-    if (terminalStatuses.includes(params.status)) {
-        const openSession = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.id);
-        if (openSession) {
-            db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(ts, openSession.id);
-            const duration = new Date(ts).getTime() - new Date(openSession.start).getTime();
-            logActivity('timer_stopped', row.title, {
-                detail: `Auto-stopped: duration ${duration}ms, status → ${params.status}`,
-                entityType: 'task',
-                entityId: params.id,
-            });
-            broadcastChange('timer', 'timer_stopped', { task_id: params.id, session: { ...openSession, end: ts, duration }, task_status: params.status });
-        }
-    }
-    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run(params.status, ts, params.id);
-    // Log appropriate action
-    let statusAction;
-    if (params.status === 'done') {
-        logActivity('task_completed', row.title, { entityType: 'task', entityId: params.id });
-        statusAction = 'task_completed';
-    }
-    else if (params.status === 'partial_done') {
-        logActivity('task_partial_done', row.title, { entityType: 'task', entityId: params.id });
-        statusAction = 'task_partial_done';
-    }
-    else {
-        logActivity('task_status_changed', row.title, {
-            detail: `${currentStatus} -> ${params.status}`,
-            entityType: 'task',
-            entityId: params.id,
-        });
-        statusAction = 'task_status_changed';
-    }
-    const updated = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
-    broadcastChange('task', statusAction, parseTask(updated));
-    return successResponse(parseTaskCompact(updated));
-}
-export async function deleteTask(params) {
-    const db = getDb();
-    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
-    if (!row)
-        return errorResponse('Task not found', 'NOT_FOUND');
-    db.prepare('DELETE FROM tasks WHERE id = ?').run(params.id);
-    logActivity('task_deleted', row.title, { entityType: 'task', entityId: params.id });
-    broadcastChange('task', 'task_deleted', { id: params.id });
-    return successResponse({ deleted: true, id: params.id });
-}
-export async function bulkCreateTasks(params) {
-    const db = getDb();
-    const ts = now();
-    const created = [];
-    const insertStmt = db.prepare(`INSERT INTO tasks (title, description, status, priority, project_id, dependencies, links, tags, due_date, estimated_time, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-    const transaction = db.transaction(() => {
-        for (const t of params.tasks) {
-            const result = insertStmt.run(t.title, t.description ?? null, t.status ?? 'not_started', t.priority ?? 'medium', t.project_id ?? null, JSON.stringify(t.dependencies ?? []), '[]', JSON.stringify(t.tags ?? []), null, null, ts, ts);
-            const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(result.lastInsertRowid);
-            created.push(parseTask(row));
-        }
-    });
-    transaction();
-    logActivity('tasks_bulk_created', `${created.length} tasks created`, {
-        detail: created.map(t => t.title).join(', '),
-    });
-    const createdTasks = created;
-    broadcastChange('task', 'tasks_bulk_created', { tasks: createdTasks });
-    return successResponse(createdTasks);
-}
-export async function searchTasks(params) {
-    const db = getDb();
-    const like = `%${params.query}%`;
-    const rows = db.prepare(`SELECT * FROM tasks WHERE title LIKE ? COLLATE NOCASE OR description LIKE ? COLLATE NOCASE`).all(like, like);
-    return successResponse(rows.map(parseTaskCompact));
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerTaskTools(server) {
-    server.tool('create_task', 'Create a new task. Use this when starting new work to keep TaskFlow in sync. Supports dependencies, tags, links, and time estimates.', {
-        title: z.string(),
-        description: z.string().optional(),
-        status: TaskStatus.optional(),
-        priority: TaskPriority.optional(),
-        project_id: z.number().optional(),
-        dependencies: z.array(z.number()).optional(),
-        tags: z.array(z.string()).optional(),
-        links: z.array(LinkSchema).optional(),
-        due_date: z.string().optional(),
-        estimated_time: z.number().optional(),
-    }, { readOnlyHint: false }, async (params) => createTask(params));
-    server.tool('list_tasks', 'List tasks with optional filters. Use at conversation start to see what is in progress or blocked. Filter by status, project, priority, or tag.', {
-        status: TaskStatus.optional(),
-        project_id: z.number().optional(),
-        priority: TaskPriority.optional(),
-        tag: z.string().optional(),
-    }, { readOnlyHint: true }, async (params) => listTasks(params));
-    server.tool('get_task', 'Get a task by ID with time tracking info. Read the description carefully — it often contains implementation details and acceptance criteria.', { id: z.number() }, { readOnlyHint: true }, async (params) => getTask(params));
-    server.tool('update_task', 'Update task fields. Use this to add details, update descriptions with progress notes, or adjust priority as you learn more.', {
-        id: z.number(),
-        title: z.string().optional(),
-        description: z.string().optional(),
-        status: TaskStatus.optional(),
-        priority: TaskPriority.optional(),
-        project_id: z.number().optional(),
-        dependencies: z.array(z.number()).optional(),
-        tags: z.array(z.string()).optional(),
-        links: z.array(LinkSchema).optional(),
-        due_date: z.string().optional(),
-        estimated_time: z.number().optional(),
-        allowed_tools: z.array(z.string()).optional().describe('Allowlist of MCP tool names for this task. If set, only these tools can be used while timer is active.'),
-        denied_tools: z.array(z.string()).optional().describe('Denylist of MCP tool names for this task. These tools are blocked while timer is active.'),
-    }, { readOnlyHint: false }, async (params) => updateTask(params));
-    server.tool('update_task_status', 'Update task status with transition validation. Use when a task becomes blocked, is partially done, or needs to be reopened.', {
-        id: z.number(),
-        status: TaskStatus,
-    }, { readOnlyHint: false }, async (params) => updateTaskStatus(params));
-    server.tool('delete_task', 'Delete a task by ID. Use sparingly — prefer updating status to "done" instead of deleting.', { id: z.number() }, { destructiveHint: true }, async (params) => deleteTask(params));
-    server.tool('bulk_create_tasks', 'Create multiple tasks in a single transaction. Useful when breaking down a feature into subtasks.', {
-        tasks: z.array(z.object({
-            title: z.string(),
-            description: z.string().optional(),
-            priority: TaskPriority.optional(),
-            project_id: z.number().optional(),
-            status: TaskStatus.optional(),
-            dependencies: z.array(z.number()).optional(),
-            tags: z.array(z.string()).optional(),
-        })),
-    }, { readOnlyHint: false }, async (params) => bulkCreateTasks(params));
-    server.tool('search_tasks', 'Search tasks by title or description. Use this to find tasks related to your current work before creating duplicates.', { query: z.string() }, { readOnlyHint: true }, async (params) => searchTasks(params));
-}

package/dist/tools/terminal.d.ts

@@ -1,4 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-/** Validate keys before sending — blocks shell escape patterns */
-export declare function validateKeys(keys: string): string | null;
-export declare function registerTerminalTools(server: McpServer): void;

package/dist/tools/terminal.js

@@ -1,98 +0,0 @@
-import { z } from 'zod';
-import { execFileSync } from 'child_process';
-import { getDb } from '../db.js';
-import { logActivity, errorResponse, successResponse } from '../helpers.js';
-const MAX_KEYS_LENGTH = 200;
-// Patterns that should never be sent via remote key injection
-const BLOCKED_PATTERNS = [
-    /^\s*!/, // Claude Code shell escape (! command)
-    /;\s*!/, // shell escape after semicolon
-];
-/** Validate keys before sending — blocks shell escape patterns */
-export function validateKeys(keys) {
-    if (keys.length > MAX_KEYS_LENGTH) {
-        return `Keys too long (${keys.length} chars, max ${MAX_KEYS_LENGTH}) — potential injection`;
-    }
-    for (const pattern of BLOCKED_PATTERNS) {
-        if (pattern.test(keys)) {
-            return 'Blocked: shell escape pattern detected (! prefix). Use the terminal directly for shell commands.';
-        }
-    }
-    return null; // valid
-}
-function getAgentPane(agentName, requireConnected = false) {
-    const db = getDb();
-    const agent = db.prepare('SELECT * FROM agent_registry WHERE name = ?').get(agentName);
-    if (!agent)
-        return { error: errorResponse(`Agent "${agentName}" not found`, 'NOT_FOUND') };
-    if (!agent.tmux_pane)
-        return { error: errorResponse(`Agent "${agentName}" has no tmux pane`, 'VALIDATION_ERROR') };
-    if (requireConnected && agent.status !== 'connected') {
-        return { error: errorResponse(`Agent "${agentName}" is disconnected — sending keys to a bare shell is blocked for security`, 'VALIDATION_ERROR') };
-    }
-    return { agent };
-}
-export function registerTerminalTools(server) {
-    server.tool('capture_terminal', 'Capture the current terminal content of an agent\'s tmux pane. Returns the visible text on screen. Useful for seeing what prompts or output an agent is displaying.', {
-        agent_name: z.string().describe('Name of the agent whose terminal to capture'),
-    }, { readOnlyHint: true }, async (params) => {
-        const result = getAgentPane(params.agent_name);
-        if (result.error)
-            return result.error;
-        try {
-            const output = execFileSync('tmux', ['capture-pane', '-p', '-S', '-', '-t', result.agent.tmux_pane], { timeout: 5000 }).toString();
-            return successResponse({
-                agent: params.agent_name,
-                pane: result.agent.tmux_pane,
-                content: output,
-            });
-        }
-        catch (err) {
-            return errorResponse(`Failed to capture pane: ${err.message}`, 'VALIDATION_ERROR');
-        }
-    });
-    server.tool('send_keys', 'Send raw keystrokes to an agent\'s tmux pane. Use this to respond to interactive prompts (yes/no, numbered choices, permission approvals) displayed in an agent\'s terminal. By default appends Enter after the keys.', {
-        agent_name: z.string().describe('Name of the agent whose terminal to send keys to'),
-        keys: z.string().describe('The keys/text to send (e.g. "yes", "1", "y") or tmux key names (e.g. "Escape", "Up", "Down", "BTab")'),
-        enter: z.boolean().optional().describe('Whether to press Enter after the keys (default: true)'),
-        literal: z.boolean().optional().describe('Send as literal text with -l flag (default: true). Set false for tmux key names like Escape, Up, Down, Left, Right, BTab'),
-    }, { destructiveHint: true }, async (params) => {
-        const result = getAgentPane(params.agent_name, true);
-        if (result.error)
-            return result.error;
-        // Validate keys for injection attacks
-        const violation = validateKeys(params.keys);
-        if (violation)
-            return errorResponse(violation, 'VALIDATION_ERROR');
-        const sendEnter = params.enter !== false;
-        const isLiteral = params.literal !== false;
-        try {
-            const pane = result.agent.tmux_pane;
-            if (isLiteral) {
-                // Send as literal text (like typing on a keyboard)
-                execFileSync('tmux', ['send-keys', '-t', pane, '-l', params.keys], { stdio: 'ignore', timeout: 5000 });
-                if (sendEnter) {
-                    execFileSync('tmux', ['send-keys', '-t', pane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
-                }
-            }
-            else {
-                // Send as tmux key names (Escape, Up, Down, etc.)
-                const args = ['send-keys', '-t', pane, params.keys];
-                if (sendEnter)
-                    args.push('Enter');
-                execFileSync('tmux', args, { stdio: 'ignore', timeout: 5000 });
-            }
-            logActivity('terminal_send_keys', `Sent keys to ${params.agent_name}: ${params.keys.slice(0, 50)}`, { entityType: 'agent' });
-            return successResponse({
-                agent: params.agent_name,
-                pane: result.agent.tmux_pane,
-                keys: params.keys,
-                enter: sendEnter,
-                sent: true,
-            });
-        }
-        catch (err) {
-            return errorResponse(`Failed to send keys: ${err.message}`, 'VALIDATION_ERROR');
-        }
-    });
-}

package/dist/tools/timer.d.ts

@@ -1,37 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function startTimer(params: {
-    task_id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function pauseTimer(params: {
-    task_id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function stopTimer(params: {
-    task_id: number;
-    final_status?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function listSessions(params: {
-    task_id?: number;
-    start_date?: string;
-    end_date?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerTimerTools(server: McpServer): void;