@dalmasonto/taskflow-mcp 1.0.35 → 2.1.0

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;

package/dist/tools/timer.js

@@ -1,154 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { logActivity, errorResponse, successResponse, now, broadcastChange } from '../helpers.js';
-import { VALID_TRANSITIONS } from '../types.js';
-// ─── exported handler functions ───────────────────────────────────────
-export async function startTimer(params) {
-    const db = getDb();
-    const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(params.task_id);
-    if (!task)
-        return errorResponse('Task not found', 'NOT_FOUND');
-    // Check no open session exists
-    const openSession = db.prepare('SELECT id FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
-    if (openSession)
-        return errorResponse('A timer session is already active for this task', 'SESSION_ALREADY_ACTIVE');
-    // Check valid transition to in_progress
-    const currentStatus = task.status;
-    const allowed = VALID_TRANSITIONS[currentStatus];
-    if (!allowed || !allowed.includes('in_progress')) {
-        return errorResponse(`Cannot transition from "${currentStatus}" to "in_progress"`, 'INVALID_TRANSITION');
-    }
-    const ts = now();
-    // Create session
-    const result = db.prepare('INSERT INTO sessions (task_id, start, end) VALUES (?, ?, ?)').run(params.task_id, ts, null);
-    // Update task status to in_progress
-    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run('in_progress', ts, params.task_id);
-    logActivity('timer_started', task.title, { entityType: 'task', entityId: params.task_id });
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(result.lastInsertRowid);
-    broadcastChange('timer', 'timer_started', { task_id: params.task_id, session, task_status: 'in_progress' });
-    return successResponse(session);
-}
-export async function pauseTimer(params) {
-    const db = getDb();
-    const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(params.task_id);
-    if (!task)
-        return errorResponse('Task not found', 'NOT_FOUND');
-    // Find open session
-    const session = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
-    const endTime = now();
-    let duration;
-    let closedSession;
-    if (session) {
-        // Normal path — close the active session
-        duration = new Date(endTime).getTime() - new Date(session.start).getTime();
-        db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(endTime, session.id);
-        closedSession = { ...session, end: endTime };
-    }
-    else {
-        // Fallback — session already closed (orphan cleanup, auto-close)
-        const lastSession = db.prepare('SELECT * FROM sessions WHERE task_id = ? ORDER BY start DESC LIMIT 1').get(params.task_id);
-        if (!lastSession)
-            return errorResponse('No timer sessions found for this task', 'NO_ACTIVE_SESSION');
-        duration = new Date(lastSession.end).getTime() - new Date(lastSession.start).getTime();
-        closedSession = lastSession;
-    }
-    // Update task to paused
-    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run('paused', endTime, params.task_id);
-    logActivity('timer_paused', task.title, {
-        detail: `Duration: ${duration}ms`,
-        entityType: 'task',
-        entityId: params.task_id,
-    });
-    const pausedSession = { ...closedSession, duration };
-    broadcastChange('timer', 'timer_paused', { task_id: params.task_id, session: pausedSession, task_status: 'paused' });
-    return successResponse(pausedSession);
-}
-export async function stopTimer(params) {
-    const db = getDb();
-    const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(params.task_id);
-    if (!task)
-        return errorResponse('Task not found', 'NOT_FOUND');
-    // Find open session
-    const session = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
-    const finalStatus = params.final_status ?? 'done';
-    const endTime = now();
-    let duration;
-    let closedSession;
-    if (session) {
-        // Normal path — close the active session
-        duration = new Date(endTime).getTime() - new Date(session.start).getTime();
-        db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(endTime, session.id);
-        closedSession = { ...session, end: endTime };
-    }
-    else {
-        // Fallback — session was already closed (e.g. by orphan cleanup or update_task_status)
-        // Still update the task status so the caller's intent is honored
-        const lastSession = db.prepare('SELECT * FROM sessions WHERE task_id = ? ORDER BY start DESC LIMIT 1').get(params.task_id);
-        if (!lastSession)
-            return errorResponse('No timer sessions found for this task', 'NO_ACTIVE_SESSION');
-        duration = new Date(lastSession.end).getTime() - new Date(lastSession.start).getTime();
-        closedSession = lastSession;
-    }
-    // Update task to final_status
-    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run(finalStatus, endTime, params.task_id);
-    logActivity('timer_stopped', task.title, {
-        detail: `Duration: ${duration}ms, final status: ${finalStatus}`,
-        entityType: 'task',
-        entityId: params.task_id,
-    });
-    // Also log status-specific action
-    if (finalStatus === 'done') {
-        logActivity('task_completed', task.title, { entityType: 'task', entityId: params.task_id });
-    }
-    else if (finalStatus === 'partial_done') {
-        logActivity('task_partial_done', task.title, { entityType: 'task', entityId: params.task_id });
-    }
-    const stoppedSession = { ...closedSession, duration };
-    broadcastChange('timer', 'timer_stopped', { task_id: params.task_id, session: stoppedSession, task_status: finalStatus });
-    return successResponse(stoppedSession);
-}
-export async function listSessions(params) {
-    const db = getDb();
-    const conditions = [];
-    const values = [];
-    if (params.task_id != null) {
-        conditions.push('task_id = ?');
-        values.push(params.task_id);
-    }
-    if (params.start_date) {
-        conditions.push('start >= ?');
-        values.push(params.start_date);
-    }
-    if (params.end_date) {
-        conditions.push('start <= ?');
-        values.push(params.end_date);
-    }
-    let sql = 'SELECT * FROM sessions';
-    if (conditions.length > 0) {
-        sql += ' WHERE ' + conditions.join(' AND ');
-    }
-    sql += ' ORDER BY start ASC';
-    const rows = db.prepare(sql).all(...values);
-    const nowMs = Date.now();
-    const sessions = rows.map(row => {
-        const startMs = new Date(row.start).getTime();
-        const endMs = row.end ? new Date(row.end).getTime() : nowMs;
-        const duration = endMs - startMs;
-        return { ...row, duration };
-    });
-    return successResponse(sessions);
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerTimerTools(server) {
-    server.tool('start_timer', 'Start a timer session for a task. Call this before beginning work on any task to track focused time. Automatically transitions the task to "in_progress".', { task_id: z.number() }, { readOnlyHint: false }, async (params) => startTimer(params));
-    server.tool('pause_timer', 'Pause the active timer session for a task. Call when switching context or waiting for user input. The task transitions to "paused".', { task_id: z.number() }, { readOnlyHint: false }, async (params) => pauseTimer(params));
-    server.tool('stop_timer', 'Stop the active timer and set a final status. Call when finishing work — use "done" if complete, "partial_done" if more remains, "blocked" if stuck.', {
-        task_id: z.number(),
-        final_status: z.enum(['done', 'partial_done', 'blocked']).optional(),
-    }, { readOnlyHint: false }, async (params) => stopTimer(params));
-    server.tool('list_sessions', 'List timer sessions with optional filters. Use to review time spent on a task or across a date range.', {
-        task_id: z.number().optional(),
-        start_date: z.string().optional(),
-        end_date: z.string().optional(),
-    }, { readOnlyHint: true }, async (params) => listSessions(params));
-}

package/dist/types.d.ts

@@ -1,83 +0,0 @@
-import { z } from 'zod';
-export declare const TaskStatus: z.ZodEnum<{
-    not_started: "not_started";
-    in_progress: "in_progress";
-    paused: "paused";
-    blocked: "blocked";
-    partial_done: "partial_done";
-    done: "done";
-}>;
-export type TaskStatus = z.infer<typeof TaskStatus>;
-export declare const TaskPriority: z.ZodEnum<{
-    low: "low";
-    medium: "medium";
-    high: "high";
-    critical: "critical";
-}>;
-export type TaskPriority = z.infer<typeof TaskPriority>;
-export declare const ProjectType: z.ZodEnum<{
-    active_project: "active_project";
-    project_idea: "project_idea";
-}>;
-export type ProjectType = z.infer<typeof ProjectType>;
-export declare const NotificationType: z.ZodEnum<{
-    info: "info";
-    error: "error";
-    success: "success";
-    warning: "warning";
-}>;
-export type NotificationType = z.infer<typeof NotificationType>;
-export declare const AgentMessageStatus: z.ZodEnum<{
-    pending: "pending";
-    answered: "answered";
-    dismissed: "dismissed";
-}>;
-export type AgentMessageStatus = z.infer<typeof AgentMessageStatus>;
-export declare const AgentStatus: z.ZodEnum<{
-    connected: "connected";
-    disconnected: "disconnected";
-}>;
-export type AgentStatus = z.infer<typeof AgentStatus>;
-export declare const ActivityAction: z.ZodEnum<{
-    task_created: "task_created";
-    task_deleted: "task_deleted";
-    task_status_changed: "task_status_changed";
-    task_completed: "task_completed";
-    task_partial_done: "task_partial_done";
-    timer_started: "timer_started";
-    timer_paused: "timer_paused";
-    timer_stopped: "timer_stopped";
-    project_created: "project_created";
-    project_deleted: "project_deleted";
-    project_updated: "project_updated";
-    tasks_bulk_created: "tasks_bulk_created";
-    settings_saved: "settings_saved";
-    data_seeded: "data_seeded";
-    data_cleared: "data_cleared";
-    task_linked: "task_linked";
-    task_unlinked: "task_unlinked";
-    dependency_added: "dependency_added";
-    dependency_removed: "dependency_removed";
-    link_added: "link_added";
-    tag_added: "tag_added";
-    tag_removed: "tag_removed";
-    debug_log: "debug_log";
-    agent_question: "agent_question";
-    agent_question_answered: "agent_question_answered";
-    agent_broadcast: "agent_broadcast";
-    agent_connected: "agent_connected";
-    agent_disconnected: "agent_disconnected";
-    agent_renamed: "agent_renamed";
-    agent_deleted: "agent_deleted";
-    terminal_send_keys: "terminal_send_keys";
-    terminal_captured: "terminal_captured";
-    compaction_summary: "compaction_summary";
-    activity_compacted: "activity_compacted";
-}>;
-export type ActivityAction = z.infer<typeof ActivityAction>;
-export declare const VALID_TRANSITIONS: Record<TaskStatus, TaskStatus[]>;
-export type ErrorCode = 'NOT_FOUND' | 'INVALID_TRANSITION' | 'VALIDATION_ERROR' | 'CYCLE_DETECTED' | 'SESSION_ALREADY_ACTIVE' | 'NO_ACTIVE_SESSION' | 'ALREADY_ANSWERED' | 'CONFLICT';
-export declare const LinkSchema: z.ZodObject<{
-    label: z.ZodString;
-    url: z.ZodString;
-}, z.core.$strip>;

package/dist/types.js

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-export const TaskStatus = z.enum([
-    'not_started', 'in_progress', 'paused', 'blocked', 'partial_done', 'done'
-]);
-export const TaskPriority = z.enum(['low', 'medium', 'high', 'critical']);
-export const ProjectType = z.enum(['active_project', 'project_idea']);
-export const NotificationType = z.enum(['info', 'success', 'warning', 'error']);
-export const AgentMessageStatus = z.enum(['pending', 'answered', 'dismissed']);
-export const AgentStatus = z.enum(['connected', 'disconnected']);
-export const ActivityAction = z.enum([
-    'task_created', 'task_deleted', 'task_status_changed', 'task_completed',
-    'task_partial_done', 'timer_started', 'timer_paused', 'timer_stopped',
-    'project_created', 'project_deleted', 'project_updated',
-    'tasks_bulk_created', 'settings_saved', 'data_seeded', 'data_cleared',
-    'task_linked', 'task_unlinked', 'dependency_added', 'dependency_removed',
-    'link_added', 'tag_added', 'tag_removed', 'debug_log',
-    'agent_question', 'agent_question_answered', 'agent_broadcast',
-    'agent_connected', 'agent_disconnected', 'agent_renamed', 'agent_deleted',
-    'terminal_send_keys', 'terminal_captured',
-    'compaction_summary', 'activity_compacted',
-]);
-export const VALID_TRANSITIONS = {
-    not_started: ['in_progress', 'blocked'],
-    in_progress: ['paused', 'blocked', 'partial_done', 'done'],
-    paused: ['in_progress', 'blocked', 'partial_done', 'done'],
-    blocked: ['not_started', 'in_progress'],
-    partial_done: ['in_progress', 'done'],
-    done: ['in_progress'],
-};
-export const LinkSchema = z.object({ label: z.string(), url: z.string() });