@dalmasonto/taskflow-mcp 1.0.35 → 2.1.0

package/dist/tmux-bridge.d.ts

@@ -1,13 +0,0 @@
-interface BridgeOptions {
-    /** Returns the current agent name — must be a getter so renames are picked up */
-    getAgentName: () => string;
-    agentPid: number;
-    /** Null when not running inside tmux — falls back to stderr delivery */
-    tmuxPane: string | null;
-}
-/**
- * Start the tmux bridge: SSE listener for instant message delivery.
- * Returns a cleanup function for graceful shutdown.
- */
-export declare function startTmuxBridge(options: BridgeOptions): () => void;
-export {};

package/dist/tmux-bridge.js

@@ -1,217 +0,0 @@
-import { execFileSync } from 'child_process';
-import { appendFileSync, mkdirSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { getDb } from './db.js';
-import { getActivePort } from './sse.js';
-import http from 'http';
-const LOG_FILE = join(homedir(), '.taskflow', 'bridge.log');
-try {
-    mkdirSync(join(homedir(), '.taskflow'), { recursive: true });
-}
-catch { }
-function blogLog(msg) {
-    const line = `${new Date().toISOString()} ${msg}\n`;
-    console.error(`[bridge] ${msg}`);
-    try {
-        appendFileSync(LOG_FILE, line);
-    }
-    catch { }
-}
-// ─── SSE Listener (replaces the 3s poller) ───────────────────────────
-function startSSEListener(options) {
-    const port = getActivePort();
-    function connect() {
-        const req = http.get(`http://localhost:${port}/events`, (res) => {
-            let buffer = '';
-            let eventType = ''; // persists across chunks — SSE fields may split across TCP segments
-            res.on('data', (chunk) => {
-                buffer += chunk.toString();
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (line.startsWith('event: ')) {
-                        eventType = line.slice(7).trim();
-                    }
-                    else if (line.startsWith('data: ') && eventType) {
-                        try {
-                            const data = JSON.parse(line.slice(6));
-                            handleSSEEvent(eventType, data, options);
-                        }
-                        catch { /* malformed JSON */ }
-                        eventType = '';
-                    }
-                    else if (line === '') {
-                        // SSE event delimiter — reset state for next event
-                        eventType = '';
-                    }
-                }
-            });
-            res.on('end', () => {
-                blogLog('SSE connection closed, reconnecting in 3s...');
-                setTimeout(connect, 3000);
-            });
-            res.on('error', () => {
-                blogLog('SSE connection error, reconnecting in 3s...');
-                setTimeout(connect, 3000);
-            });
-        });
-        req.on('error', () => {
-            blogLog('SSE connect failed, retrying in 3s...');
-            setTimeout(connect, 3000);
-        });
-    }
-    // Initial sweep: deliver any undelivered messages from before SSE connected
-    deliverUndelivered(options);
-    connect();
-}
-function handleSSEEvent(event, data, options) {
-    const { getAgentName, agentPid, tmuxPane } = options;
-    const agentName = getAgentName();
-    const payload = data.payload;
-    if (!payload)
-        return;
-    if (event === 'agent_question') {
-        const recipient = payload.recipient_name;
-        const sender = payload.sender_name;
-        const status = payload.status;
-        const id = payload.id;
-        const delivered = payload.delivered;
-        if (recipient !== agentName || status !== 'pending' || delivered === 1)
-            return;
-        let text;
-        if (sender === 'user') {
-            text = `[Message from User]: ${payload.question}`;
-        }
-        else {
-            text = `[Message from ${sender}]: ${payload.question}`;
-        }
-        injectAndMarkDelivered(id, text, tmuxPane);
-    }
-    if (event === 'agent_question_answered') {
-        const sender = payload.sender_name;
-        const recipient = payload.recipient_name;
-        const status = payload.status;
-        const id = payload.id;
-        const delivered = payload.delivered;
-        const agentPidField = payload.agent_pid;
-        const isOurs = sender === agentName || agentPidField === agentPid;
-        if (!isOurs || status !== 'answered' || delivered === 1)
-            return;
-        const question = (payload.question || '').slice(0, 60);
-        const response = payload.response;
-        const text = `[Inbox Response] to "${question}": ${response}`;
-        injectAndMarkDelivered(id, text, tmuxPane);
-    }
-}
-// TIOCSTI Python script — injects each character of `text` + newline into the
-// controlling terminal's input queue via ioctl(TIOCSTI). Passed as a CLI arg
-// (not inline) so special characters in the message are never shell-interpreted.
-const TIOCSTI_SCRIPT = `
-import fcntl, sys
-TIOCSTI = 0x5412
-with open('/dev/tty', 'rb+', buffering=0) as tty:
-    for c in (sys.argv[1] + '\\n').encode():
-        fcntl.ioctl(tty, TIOCSTI, bytes([c]))
-`.trim();
-function injectViaTiocsti(text) {
-    try {
-        execFileSync('python3', ['-c', TIOCSTI_SCRIPT, text], { timeout: 5000 });
-        return null;
-    }
-    catch (err) {
-        // Capture stderr from the Python process (where the real error lives)
-        const stderr = err?.stderr?.toString().trim() || '';
-        const stdout = err?.stdout?.toString().trim() || '';
-        const msg = err?.message || String(err);
-        return [msg, stderr, stdout].filter(Boolean).join(' | ');
-    }
-}
-function injectAndMarkDelivered(id, text, tmuxPane) {
-    const db = getDb();
-    db.prepare('UPDATE agent_messages SET delivered = 1 WHERE id = ?').run(id);
-    if (tmuxPane) {
-        try {
-            // Send text literally (-l) so special chars are safe and tmux doesn't interpret them
-            execFileSync('tmux', ['send-keys', '-t', tmuxPane, '-l', text], { stdio: 'ignore', timeout: 5000 });
-            // Delay before Enter — gives the CLI time to fully process the bracketed paste.
-            // Without this, Codex (and similar TUIs) may only show partial text because
-            // the Enter arrives inside the paste bracket and gets swallowed.
-            setTimeout(() => {
-                try {
-                    execFileSync('tmux', ['send-keys', '-t', tmuxPane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
-                }
-                catch { /* pane may have closed */ }
-                // Second Enter after another delay — catches CLIs that need an extra nudge
-                // after bracketed paste ends (e.g. long messages that trigger paste mode)
-                setTimeout(() => {
-                    try {
-                        execFileSync('tmux', ['send-keys', '-t', tmuxPane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
-                    }
-                    catch { /* pane may have closed */ }
-                }, 500);
-            }, 300);
-            blogLog(`delivered message ${id} to tmux pane ${tmuxPane}`);
-        }
-        catch (err) {
-            blogLog(`tmux send-keys failed for message ${id}: ${err}`);
-        }
-    }
-    else {
-        // Non-tmux: try TIOCSTI to inject text into the controlling terminal's input
-        // queue. TIOCSTI (0x5412) works when the caller shares the controlling terminal
-        // with the target process — which is true here since the MCP server is a child
-        // of Claude Code and inherits its tty session.
-        // Falls back to stderr if python3 is unavailable or the ioctl is denied.
-        const tiocError = injectViaTiocsti(text);
-        if (tiocError !== null) {
-            blogLog(`TIOCSTI failed for message ${id}: ${tiocError}`);
-            // Last-resort visual: at least make the message visible in the terminal output.
-            // The tool-response piggyback in index.ts will also deliver it on the next call.
-            process.stderr.write(`\n\x1b[33m[INBOX #${id}]: ${text}\x1b[0m\n`);
-            blogLog(`message ${id} visible in stderr, will appear in next tool response`);
-        }
-        else {
-            blogLog(`delivered message ${id} via TIOCSTI`);
-        }
-    }
-}
-function deliverUndelivered(options) {
-    const { getAgentName, agentPid, tmuxPane } = options;
-    const agentName = getAgentName();
-    const db = getDb();
-    const incoming = db.prepare(`SELECT * FROM agent_messages WHERE delivered IS NULL AND (
-      (recipient_name = ? AND status = 'pending') OR
-      (sender_name = ? AND status = 'answered') OR
-      (agent_pid = ? AND status = 'answered')
-    )`).all(agentName, agentName, agentPid);
-    for (const msg of incoming) {
-        let text;
-        if (msg.recipient_name === agentName && msg.sender_name === 'user') {
-            text = `[Message from User]: ${msg.question}`;
-        }
-        else if (msg.recipient_name === agentName && msg.sender_name !== 'user') {
-            text = `[Message from ${msg.sender_name}]: ${msg.question}`;
-        }
-        else if (msg.status === 'answered' && msg.response) {
-            text = `[Inbox Response] to "${msg.question.slice(0, 60)}": ${msg.response}`;
-        }
-        else {
-            continue;
-        }
-        injectAndMarkDelivered(msg.id, text, tmuxPane);
-    }
-}
-// ─── Public API ──────────────────────────────────────────────────────
-/**
- * Start the tmux bridge: SSE listener for instant message delivery.
- * Returns a cleanup function for graceful shutdown.
- */
-export function startTmuxBridge(options) {
-    startSSEListener(options);
-    const pane = options.tmuxPane;
-    blogLog(`bridge active for agent "${options.getAgentName()}"${pane ? ` on tmux pane ${pane}` : ' (TIOCSTI mode — no tmux pane)'}`);
-    return () => {
-        // SSE connection will close when process exits
-    };
-}

package/dist/tools/activity.d.ts

@@ -1,39 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function getActivityLog(params: {
-    limit?: number;
-    action?: string;
-    entity_type?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function clearActivityLog(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function compactActivityLog(params: {
-    preserve_recent?: number;
-    max_entries?: number;
-    dry_run?: boolean;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function logDebug(params: {
-    message: string;
-    task_id?: number;
-    project_id?: number;
-    detail?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerActivityTools(server: McpServer): void;

package/dist/tools/activity.js

@@ -1,152 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { successResponse, broadcastChange } from '../helpers.js';
-// ─── exported handler functions ───────────────────────────────────────
-export async function getActivityLog(params) {
-    const db = getDb();
-    const limit = params.limit ?? 50;
-    const conditions = [];
-    const values = [];
-    if (params.action) {
-        conditions.push('action = ?');
-        values.push(params.action);
-    }
-    if (params.entity_type) {
-        conditions.push('entity_type = ?');
-        values.push(params.entity_type);
-    }
-    let sql = 'SELECT * FROM activity_logs';
-    if (conditions.length > 0) {
-        sql += ' WHERE ' + conditions.join(' AND ');
-    }
-    sql += ' ORDER BY created_at DESC LIMIT ?';
-    values.push(limit);
-    const rows = db.prepare(sql).all(...values);
-    return successResponse(rows);
-}
-export async function clearActivityLog() {
-    const db = getDb();
-    const countRow = db.prepare('SELECT COUNT(*) AS count FROM activity_logs').get();
-    db.prepare('DELETE FROM activity_logs').run();
-    broadcastChange('activity', 'activity_cleared', {});
-    return successResponse({ deleted: countRow.count, message: 'Activity log cleared' });
-}
-// ─── compaction ──────────────────────────────────────────────────────
-const DEFAULT_PRESERVE_RECENT = 50;
-const DEFAULT_MAX_LOG_ENTRIES = 500;
-/** Actions that are always preserved in full (never compacted) */
-const MILESTONE_ACTIONS = new Set([
-    'task_created', 'task_completed', 'task_partial_done',
-    'project_created', 'project_deleted',
-    'agent_connected', 'agent_disconnected', 'agent_renamed',
-]);
-export async function compactActivityLog(params) {
-    const db = getDb();
-    const preserveRecent = params.preserve_recent ?? DEFAULT_PRESERVE_RECENT;
-    const maxEntries = params.max_entries ?? DEFAULT_MAX_LOG_ENTRIES;
-    const totalCount = db.prepare('SELECT COUNT(*) AS count FROM activity_logs').get().count;
-    if (totalCount <= maxEntries) {
-        return successResponse({
-            compacted: false,
-            total_entries: totalCount,
-            message: `Log has ${totalCount} entries (threshold: ${maxEntries}) — no compaction needed.`,
-        });
-    }
-    // Get all entries sorted by date
-    const allEntries = db.prepare('SELECT * FROM activity_logs ORDER BY created_at ASC').all();
-    // Split into: entries to compact vs entries to preserve
-    const cutoffIndex = allEntries.length - preserveRecent;
-    const toCompact = allEntries.slice(0, cutoffIndex);
-    const toPreserve = allEntries.slice(cutoffIndex);
-    if (toCompact.length === 0) {
-        return successResponse({
-            compacted: false,
-            total_entries: totalCount,
-            message: 'All entries are within the preserve window — nothing to compact.',
-        });
-    }
-    // Generate summary of compacted entries
-    const actionCounts = {};
-    const milestones = [];
-    const timeRange = {
-        start: toCompact[0].created_at,
-        end: toCompact[toCompact.length - 1].created_at,
-    };
-    for (const entry of toCompact) {
-        actionCounts[entry.action] = (actionCounts[entry.action] || 0) + 1;
-        if (MILESTONE_ACTIONS.has(entry.action)) {
-            milestones.push(`[${entry.created_at.slice(0, 16)}] ${entry.action}: ${entry.title}`);
-        }
-    }
-    const summaryDetail = [
-        `## Compaction Summary`,
-        `**Period:** ${timeRange.start} → ${timeRange.end}`,
-        `**Entries compacted:** ${toCompact.length}`,
-        ``,
-        `### Action Counts`,
-        ...Object.entries(actionCounts)
-            .sort((a, b) => b[1] - a[1])
-            .map(([action, count]) => `- \`${action}\`: ${count}`),
-        ``,
-        `### Key Milestones`,
-        ...(milestones.length > 0
-            ? milestones.slice(-20).map(m => `- ${m}`)
-            : ['- (none)']),
-    ].join('\n');
-    if (params.dry_run) {
-        return successResponse({
-            compacted: false,
-            dry_run: true,
-            would_compact: toCompact.length,
-            would_preserve: toPreserve.length,
-            summary_preview: summaryDetail,
-        });
-    }
-    // Delete compacted entries and insert summary
-    const compactIds = toCompact.map(e => e.id);
-    const placeholders = compactIds.map(() => '?').join(',');
-    db.prepare(`DELETE FROM activity_logs WHERE id IN (${placeholders})`).run(...compactIds);
-    const now = new Date().toISOString();
-    db.prepare(`INSERT INTO activity_logs (action, title, detail, entity_type, entity_id, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`).run('compaction_summary', `Compacted ${toCompact.length} activity log entries (${timeRange.start.slice(0, 10)} → ${timeRange.end.slice(0, 10)})`, summaryDetail, null, null, now);
-    broadcastChange('activity', 'activity_compacted', { compacted: toCompact.length, preserved: toPreserve.length });
-    return successResponse({
-        compacted: true,
-        entries_removed: toCompact.length,
-        entries_preserved: toPreserve.length,
-        summary_inserted: true,
-        new_total: toPreserve.length + 1,
-    });
-}
-export async function logDebug(params) {
-    const db = getDb();
-    const now = new Date().toISOString();
-    // task_id takes priority; fall back to project_id
-    const entityType = params.task_id ? 'task' : params.project_id ? 'project' : null;
-    const entityId = params.task_id ?? params.project_id ?? null;
-    const result = db.prepare(`INSERT INTO activity_logs (action, title, detail, entity_type, entity_id, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`).run('debug_log', params.message, params.detail ?? null, entityType, entityId, now);
-    const entry = db.prepare('SELECT * FROM activity_logs WHERE id = ?').get(result.lastInsertRowid);
-    broadcastChange('activity', 'activity_logged', entry);
-    return successResponse({ id: result.lastInsertRowid, message: params.message });
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerActivityTools(server) {
-    server.tool('get_activity_log', 'Retrieve recent activity log entries. Shows what has changed — task completions, timer events, status transitions. Filter by action or entity type.', {
-        limit: z.number().optional(),
-        action: z.string().optional(),
-        entity_type: z.string().optional(),
-    }, { readOnlyHint: true }, async (params) => getActivityLog(params));
-    server.tool('clear_activity_log', 'Delete all activity log entries. Use with caution — this is irreversible.', {}, { destructiveHint: true }, async () => clearActivityLog());
-    server.tool('log_debug', 'Log a debug entry to the activity log. Use this to record your work process — what you investigated, commands you ran, decisions you made, and findings. Entries appear in the Activity Pulse and on the project page. Link to a task (task_id) or project (project_id) for context.', {
-        message: z.string().describe('Short summary of what you are doing or found'),
-        detail: z.string().optional().describe('Longer explanation — stack traces, error messages, hypotheses, commands run, what you tried'),
-        task_id: z.number().optional().describe('Link this debug log to a specific task'),
-        project_id: z.number().optional().describe('Link this debug log to a project (used when no specific task applies)'),
-    }, { readOnlyHint: false }, async (params) => logDebug(params));
-    server.tool('compact_activity_log', 'Compact old activity log entries into a summary. Keeps the most recent entries (default 50) and summarizes the rest. Use dry_run=true to preview what would be compacted. Runs automatically when log exceeds max_entries threshold.', {
-        preserve_recent: z.number().optional().describe('Number of recent entries to keep verbatim (default: 50)'),
-        max_entries: z.number().optional().describe('Only compact if log exceeds this count (default: 500)'),
-        dry_run: z.boolean().optional().describe('If true, show what would be compacted without doing it'),
-    }, { readOnlyHint: false }, async (params) => compactActivityLog(params));
-}

package/dist/tools/agent-inbox.d.ts

@@ -1,12 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-/** The name assigned to this agent after registration */
-declare let myAgentName: string | null;
-/** Set the agent name from external registration (index.ts).
- *  This prevents double-registration when index.ts registers at startup
- *  and ensureRegistered() would register again on first tool call.
- */
-export declare function setAgentName(name: string): void;
-export { myAgentName };
-/** Get the current agent name — used by tmux bridge to track renames */
-export declare function getAgentName(): string;
-export declare function registerAgentInboxTools(server: McpServer): void;