@renseiai/agentfactory-mcp-server 0.8.0

package/dist/src/auth.d.ts

@@ -0,0 +1,6 @@
+export declare function isMcpAuthConfigured(): boolean;
+export declare function verifyMcpAuth(authHeader: string | null | undefined): {
+    authorized: boolean;
+    error?: string;
+};
+//# sourceMappingURL=auth.d.ts.map

package/dist/src/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":"AAIA,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG;IAAE,UAAU,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAuB5G"}

package/dist/src/auth.js

@@ -0,0 +1,25 @@
+import { extractBearerToken, verifyApiKey, isWorkerAuthConfigured } from '@renseiai/agentfactory-server';
+const MCP_API_KEY_ENV = 'MCP_API_KEY';
+export function isMcpAuthConfigured() {
+    return isWorkerAuthConfigured(MCP_API_KEY_ENV) || isWorkerAuthConfigured('WORKER_API_KEY');
+}
+export function verifyMcpAuth(authHeader) {
+    if (!isMcpAuthConfigured()) {
+        // No auth configured — allow all requests (dev mode)
+        return { authorized: true };
+    }
+    const token = extractBearerToken(authHeader);
+    if (!token) {
+        return { authorized: false, error: 'Missing or invalid Authorization header. Expected: Bearer <api-key>' };
+    }
+    // Try MCP-specific key first, then fall back to worker key
+    const mcpKey = process.env[MCP_API_KEY_ENV];
+    const workerKey = process.env.WORKER_API_KEY;
+    if (mcpKey && verifyApiKey(token, mcpKey)) {
+        return { authorized: true };
+    }
+    if (workerKey && verifyApiKey(token, workerKey)) {
+        return { authorized: true };
+    }
+    return { authorized: false, error: 'Invalid API key' };
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/src/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":""}

package/dist/src/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { createFleetMcpServer } from './server.js';
+import { startStdioTransport, startHttpTransport } from './transport.js';
+import { stopResourceNotificationPoller } from './resources.js';
+const args = process.argv.slice(2);
+const transportType = args.includes('--stdio') ? 'stdio' : 'http';
+const server = createFleetMcpServer();
+if (transportType === 'stdio') {
+    console.error('[mcp-server] Starting in STDIO mode');
+    await startStdioTransport(server);
+    // Graceful shutdown for STDIO mode
+    const shutdown = () => {
+        console.error('[mcp-server] Shutting down...');
+        stopResourceNotificationPoller();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+else {
+    const portIdx = args.indexOf('--port');
+    const port = portIdx !== -1 ? parseInt(args[portIdx + 1], 10) : undefined;
+    const hostIdx = args.indexOf('--host');
+    const host = hostIdx !== -1 ? args[hostIdx + 1] : undefined;
+    const httpServer = await startHttpTransport(server, { port, host });
+    // Graceful shutdown for HTTP mode — close server before exiting
+    const shutdown = () => {
+        console.log('[mcp-server] Shutting down...');
+        stopResourceNotificationPoller();
+        httpServer.close(() => {
+            process.exit(0);
+        });
+        // Force exit after 5s if connections don't drain
+        setTimeout(() => process.exit(0), 5000).unref();
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export { createFleetMcpServer } from './server.js';
+export { registerFleetTools } from './tools.js';
+export { registerFleetResources, stopResourceNotificationPoller } from './resources.js';
+export { startStdioTransport, startHttpTransport, type HttpTransportOptions } from './transport.js';
+export { verifyMcpAuth, isMcpAuthConfigured } from './auth.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,sBAAsB,EAAE,8BAA8B,EAAE,MAAM,gBAAgB,CAAA;AACvF,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AACnG,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export { createFleetMcpServer } from './server.js';
+export { registerFleetTools } from './tools.js';
+export { registerFleetResources, stopResourceNotificationPoller } from './resources.js';
+export { startStdioTransport, startHttpTransport } from './transport.js';
+export { verifyMcpAuth, isMcpAuthConfigured } from './auth.js';

package/dist/src/resources.d.ts

@@ -0,0 +1,16 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Registers MCP resources that expose AgentFactory fleet state to MCP-aware clients.
+ *
+ * Resources:
+ *   - fleet://agents        — Current fleet state (agents, statuses, costs)
+ *   - fleet://issues/{id}   — Issue details with agent progress
+ *   - fleet://logs/{id}     — Agent activity logs / session info
+ *
+ * Also starts a polling loop that emits resource-update notifications
+ * when fleet state changes, enabling MCP clients to subscribe to updates.
+ */
+export declare function registerFleetResources(server: McpServer): void;
+/** Stop the resource notification poller (for graceful shutdown) */
+export declare function stopResourceNotificationPoller(): void;
+//# sourceMappingURL=resources.d.ts.map

package/dist/src/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAUxE;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAsG9D;AA4DD,oEAAoE;AACpE,wBAAgB,8BAA8B,IAAI,IAAI,CAKrD"}

package/dist/src/resources.js

@@ -0,0 +1,142 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { getAllSessions, getSessionState, getSessionStateByIssue, listWorkers, getTotalCapacity, } from '@renseiai/agentfactory-server';
+/**
+ * Registers MCP resources that expose AgentFactory fleet state to MCP-aware clients.
+ *
+ * Resources:
+ *   - fleet://agents        — Current fleet state (agents, statuses, costs)
+ *   - fleet://issues/{id}   — Issue details with agent progress
+ *   - fleet://logs/{id}     — Agent activity logs / session info
+ *
+ * Also starts a polling loop that emits resource-update notifications
+ * when fleet state changes, enabling MCP clients to subscribe to updates.
+ */
+export function registerFleetResources(server) {
+    // 1. fleet://agents — Current fleet state
+    server.resource('fleet-agents', 'fleet://agents', { description: 'Current fleet state including all agent sessions, workers, and capacity' }, async (uri) => {
+        const [sessions, workers, capacity] = await Promise.all([
+            getAllSessions(),
+            listWorkers(),
+            getTotalCapacity(),
+        ]);
+        const data = { sessions, workers, capacity };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: JSON.stringify(data, null, 2),
+                    mimeType: 'application/json',
+                },
+            ],
+        };
+    });
+    // 2. fleet://issues/{id} — Issue details with agent progress
+    server.resource('fleet-issue', new ResourceTemplate('fleet://issues/{id}', { list: undefined }), { description: 'Issue details with agent session progress' }, async (uri, variables) => {
+        const id = Array.isArray(variables.id) ? variables.id[0] : variables.id;
+        const session = await getSessionStateByIssue(id);
+        const data = session
+            ? session
+            : { error: 'not_found', message: `No agent session found for issue: ${id}` };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: JSON.stringify(data, null, 2),
+                    mimeType: 'application/json',
+                },
+            ],
+        };
+    });
+    // 3. fleet://logs/{id} — Agent activity logs
+    server.resource('fleet-logs', new ResourceTemplate('fleet://logs/{id}', { list: undefined }), { description: 'Agent activity logs and session information' }, async (uri, variables) => {
+        const id = Array.isArray(variables.id) ? variables.id[0] : variables.id;
+        // Try to find the session by linearSessionId first, then fall back to issue ID
+        let session = await getSessionState(id);
+        if (!session) {
+            session = await getSessionStateByIssue(id);
+        }
+        if (!session) {
+            const data = { error: 'not_found', message: `No agent session found for id: ${id}` };
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        text: JSON.stringify(data, null, 2),
+                        mimeType: 'application/json',
+                    },
+                ],
+            };
+        }
+        const data = {
+            ...session,
+            _logHint: session.worktreePath
+                ? `Activity logs may be available on disk at: ${session.worktreePath}/.agent/state.json`
+                : 'No worktree path available for this session',
+        };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: JSON.stringify(data, null, 2),
+                    mimeType: 'application/json',
+                },
+            ],
+        };
+    });
+    // ─── Resource update notifications ────────────────────────────────────
+    // Poll fleet state and emit MCP resource-update notifications when changes
+    // are detected, so subscribed clients automatically refresh.
+    startResourceNotificationPoller(server);
+}
+// ─── Polling-based resource notifications ─────────────────────────────────
+const POLL_INTERVAL_MS = 5_000;
+let pollTimer = null;
+function buildSnapshot(sessions) {
+    const counts = new Map();
+    for (const s of sessions) {
+        counts.set(s.status, (counts.get(s.status) ?? 0) + 1);
+    }
+    const statusSummary = [...counts.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([k, v]) => `${k}:${v}`)
+        .join(',');
+    return { sessionCount: sessions.length, statusSummary };
+}
+function snapshotsEqual(a, b) {
+    if (!a)
+        return false;
+    return a.sessionCount === b.sessionCount && a.statusSummary === b.statusSummary;
+}
+function startResourceNotificationPoller(server) {
+    let lastSnapshot = null;
+    pollTimer = setInterval(async () => {
+        try {
+            const sessions = await getAllSessions();
+            const snapshot = buildSnapshot(sessions);
+            if (!snapshotsEqual(lastSnapshot, snapshot)) {
+                lastSnapshot = snapshot;
+                // Notify subscribed clients that fleet://agents has changed
+                try {
+                    await server.server.sendResourceUpdated({ uri: 'fleet://agents' });
+                }
+                catch {
+                    // Client may not be subscribed — safe to ignore
+                }
+            }
+        }
+        catch {
+            // Redis may be unavailable — skip this tick
+        }
+    }, POLL_INTERVAL_MS);
+    // Ensure the timer doesn't prevent process exit
+    if (pollTimer && typeof pollTimer === 'object' && 'unref' in pollTimer) {
+        pollTimer.unref();
+    }
+}
+/** Stop the resource notification poller (for graceful shutdown) */
+export function stopResourceNotificationPoller() {
+    if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+    }
+}

package/dist/src/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createFleetMcpServer(): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/src/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAInE,wBAAgB,oBAAoB,IAAI,SAAS,CAUhD"}

package/dist/src/server.js

@@ -0,0 +1,12 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerFleetResources } from './resources.js';
+import { registerFleetTools } from './tools.js';
+export function createFleetMcpServer() {
+    const server = new McpServer({
+        name: 'agentfactory-fleet',
+        version: '0.7.52',
+    });
+    registerFleetTools(server);
+    registerFleetResources(server);
+    return server;
+}

package/dist/src/tools.d.ts

@@ -0,0 +1,14 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register all fleet management tools on the MCP server.
+ *
+ * Tools registered:
+ * - submit-task: Submit a development task to the fleet work queue
+ * - get-task-status: Get current status of a task by session or issue ID
+ * - list-fleet: List agents and their statuses with optional filtering
+ * - get-cost-report: Get cost/token usage for a task or the entire fleet
+ * - stop-agent: Request to stop a running agent
+ * - forward-prompt: Forward a follow-up prompt to a running agent session
+ */
+export declare function registerFleetTools(server: McpServer): void;
+//# sourceMappingURL=tools.d.ts.map

package/dist/src/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAqCxE;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAqX1D"}

package/dist/src/tools.js

@@ -0,0 +1,333 @@
+import { z } from 'zod';
+import { getAllSessions, getSessionsByStatus, getSessionState, getSessionStateByIssue, storeSessionState, updateSessionStatus, storePendingPrompt, } from '@renseiai/agentfactory-server';
+// Work type values for zod enum validation
+const WORK_TYPES = [
+    'research',
+    'backlog-creation',
+    'development',
+    'inflight',
+    'qa',
+    'acceptance',
+    'refinement',
+    'coordination',
+    'qa-coordination',
+    'acceptance-coordination',
+];
+// Session status values for zod enum validation
+const SESSION_STATUSES = [
+    'pending',
+    'claimed',
+    'running',
+    'finalizing',
+    'completed',
+    'failed',
+    'stopped',
+];
+/**
+ * Register all fleet management tools on the MCP server.
+ *
+ * Tools registered:
+ * - submit-task: Submit a development task to the fleet work queue
+ * - get-task-status: Get current status of a task by session or issue ID
+ * - list-fleet: List agents and their statuses with optional filtering
+ * - get-cost-report: Get cost/token usage for a task or the entire fleet
+ * - stop-agent: Request to stop a running agent
+ * - forward-prompt: Forward a follow-up prompt to a running agent session
+ */
+export function registerFleetTools(server) {
+    // ─── submit-task ───────────────────────────────────────────────────
+    server.tool('submit-task', 'Submit a development task to the fleet work queue. Creates a pending session that a worker will pick up.', {
+        issueId: z.string().describe('Linear issue ID to work on'),
+        description: z.string().optional().describe('Optional description or prompt context for the task'),
+        workType: z.enum(WORK_TYPES).optional().describe('Type of work to perform (defaults to development)'),
+        priority: z.number().min(1).max(5).optional().describe('Priority 1-5 where 1 is highest (defaults to 3)'),
+    }, async (args) => {
+        try {
+            const linearSessionId = `mcp-${Date.now()}-${args.issueId}`;
+            const session = await storeSessionState(linearSessionId, {
+                issueId: args.issueId,
+                providerSessionId: null,
+                worktreePath: '',
+                status: 'pending',
+                priority: args.priority ?? 3,
+                promptContext: args.description,
+                workType: args.workType ?? 'development',
+                queuedAt: Math.floor(Date.now() / 1000),
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            submitted: true,
+                            taskId: session.linearSessionId,
+                            issueId: session.issueId,
+                            status: session.status,
+                            priority: session.priority,
+                            workType: session.workType,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── get-task-status ───────────────────────────────────────────────
+    server.tool('get-task-status', 'Get the current status of a task. Accepts either a session ID (taskId) or a Linear issue ID.', {
+        taskId: z.string().describe('Session ID or Linear issue ID to look up'),
+    }, async (args) => {
+        try {
+            // Try direct session lookup first
+            let session = await getSessionState(args.taskId);
+            // Fall back to issue-based lookup
+            if (!session) {
+                session = await getSessionStateByIssue(args.taskId);
+            }
+            if (!session) {
+                return {
+                    content: [{ type: 'text', text: `Error: No task found for ID "${args.taskId}"` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(session, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── list-fleet ────────────────────────────────────────────────────
+    server.tool('list-fleet', 'List agents in the fleet with optional status filtering and result limiting.', {
+        status: z.array(z.enum(SESSION_STATUSES)).optional().describe('Filter by one or more statuses'),
+        limit: z.number().min(1).optional().describe('Maximum number of results to return (defaults to 20)'),
+    }, async (args) => {
+        try {
+            const limit = args.limit ?? 20;
+            let sessions;
+            if (args.status && args.status.length > 0) {
+                sessions = await getSessionsByStatus(args.status);
+            }
+            else {
+                sessions = await getAllSessions();
+            }
+            const limited = sessions.slice(0, limit);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            total: sessions.length,
+                            returned: limited.length,
+                            sessions: limited,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── get-cost-report ───────────────────────────────────────────────
+    server.tool('get-cost-report', 'Get cost and token usage report. If a taskId is provided, returns cost for that specific task. Otherwise, returns aggregate fleet costs.', {
+        taskId: z.string().optional().describe('Session ID or issue ID for a specific task (omit for fleet-wide report)'),
+    }, async (args) => {
+        try {
+            if (args.taskId) {
+                // Single-task cost report
+                let session = await getSessionState(args.taskId);
+                if (!session) {
+                    session = await getSessionStateByIssue(args.taskId);
+                }
+                if (!session) {
+                    return {
+                        content: [{ type: 'text', text: `Error: No task found for ID "${args.taskId}"` }],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                taskId: session.linearSessionId,
+                                issueId: session.issueId,
+                                issueIdentifier: session.issueIdentifier,
+                                status: session.status,
+                                totalCostUsd: session.totalCostUsd ?? 0,
+                                inputTokens: session.inputTokens ?? 0,
+                                outputTokens: session.outputTokens ?? 0,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Fleet-wide cost report
+            const sessions = await getAllSessions();
+            let totalCostUsd = 0;
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            let sessionsWithCost = 0;
+            for (const session of sessions) {
+                if (session.totalCostUsd != null) {
+                    totalCostUsd += session.totalCostUsd;
+                    sessionsWithCost++;
+                }
+                if (session.inputTokens != null) {
+                    totalInputTokens += session.inputTokens;
+                }
+                if (session.outputTokens != null) {
+                    totalOutputTokens += session.outputTokens;
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            totalSessions: sessions.length,
+                            sessionsWithCostData: sessionsWithCost,
+                            totalCostUsd,
+                            totalInputTokens,
+                            totalOutputTokens,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── forward-prompt ────────────────────────────────────────────────
+    server.tool('forward-prompt', 'Forward a follow-up prompt to a running agent session. The prompt is queued and delivered to the agent via its message injection mechanism.', {
+        taskId: z.string().describe('Session ID or Linear issue ID of the running agent'),
+        message: z.string().describe('The follow-up prompt or message to send to the agent'),
+    }, async (args) => {
+        try {
+            // Resolve the session — try direct lookup, then issue-based
+            let session = await getSessionState(args.taskId);
+            if (!session) {
+                session = await getSessionStateByIssue(args.taskId);
+            }
+            if (!session) {
+                return {
+                    content: [{ type: 'text', text: `Error: No task found for ID "${args.taskId}"` }],
+                    isError: true,
+                };
+            }
+            // Only allow forwarding to active sessions
+            const forwardableStatuses = ['running', 'claimed'];
+            if (!forwardableStatuses.includes(session.status)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: Task "${session.linearSessionId}" is in status "${session.status}". Prompts can only be forwarded to running or claimed sessions.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const pending = await storePendingPrompt(session.linearSessionId, session.issueId, args.message);
+            if (!pending) {
+                return {
+                    content: [{ type: 'text', text: `Error: Failed to store pending prompt. Redis may not be configured.` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            forwarded: true,
+                            promptId: pending.id,
+                            taskId: session.linearSessionId,
+                            issueId: session.issueId,
+                            sessionStatus: session.status,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── stop-agent ────────────────────────────────────────────────────
+    server.tool('stop-agent', 'Request to stop a running agent. Updates the session status to stopped.', {
+        taskId: z.string().describe('Session ID of the task to stop'),
+    }, async (args) => {
+        try {
+            // Verify the session exists and is in a stoppable state
+            let session = await getSessionState(args.taskId);
+            if (!session) {
+                session = await getSessionStateByIssue(args.taskId);
+            }
+            if (!session) {
+                return {
+                    content: [{ type: 'text', text: `Error: No task found for ID "${args.taskId}"` }],
+                    isError: true,
+                };
+            }
+            const stoppableStatuses = ['pending', 'claimed', 'running'];
+            if (!stoppableStatuses.includes(session.status)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: Task "${session.linearSessionId}" is in status "${session.status}" and cannot be stopped. Only pending, claimed, or running tasks can be stopped.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const updated = await updateSessionStatus(session.linearSessionId, 'stopped');
+            if (!updated) {
+                return {
+                    content: [{ type: 'text', text: `Error: Failed to update task status. Redis may not be configured.` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            stopped: true,
+                            taskId: session.linearSessionId,
+                            issueId: session.issueId,
+                            previousStatus: session.status,
+                            newStatus: 'stopped',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/src/tools.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tools.test.d.ts.map

package/dist/src/tools.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.test.d.ts","sourceRoot":"","sources":["../../src/tools.test.ts"],"names":[],"mappings":""}

package/dist/src/tools.test.js

@@ -0,0 +1,326 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// ── Mock @renseiai/agentfactory-server ────────────────────────────────────────
+vi.mock('@renseiai/agentfactory-server', () => ({
+    getAllSessions: vi.fn(),
+    getSessionsByStatus: vi.fn(),
+    getSessionState: vi.fn(),
+    getSessionStateByIssue: vi.fn(),
+    storeSessionState: vi.fn(),
+    updateSessionStatus: vi.fn(),
+    storePendingPrompt: vi.fn(),
+}));
+// ── Mock @modelcontextprotocol/sdk ──────────────────────────────────────────
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
+    McpServer: vi.fn(),
+}));
+import { getAllSessions, getSessionsByStatus, getSessionState, getSessionStateByIssue, storeSessionState, updateSessionStatus, storePendingPrompt, } from '@renseiai/agentfactory-server';
+import { registerFleetTools } from './tools.js';
+/** Capture tool registrations from registerFleetTools */
+function captureTools() {
+    const tools = new Map();
+    const fakeMcpServer = {
+        tool: (name, _description, _schema, handler) => {
+            tools.set(name, handler);
+        },
+    };
+    registerFleetTools(fakeMcpServer);
+    return tools;
+}
+function makeSession(overrides = {}) {
+    return {
+        linearSessionId: 'ses-123',
+        issueId: 'issue-abc',
+        issueIdentifier: 'SUP-100',
+        providerSessionId: null,
+        worktreePath: '/tmp/wt',
+        status: 'running',
+        priority: 3,
+        workType: 'development',
+        queuedAt: 1000,
+        totalCostUsd: 0.5,
+        inputTokens: 1000,
+        outputTokens: 500,
+        ...overrides,
+    };
+}
+function parseResult(result) {
+    return JSON.parse(result.content[0].text);
+}
+// ── Tests ───────────────────────────────────────────────────────────────────
+let tools;
+beforeEach(() => {
+    vi.resetAllMocks();
+    tools = captureTools();
+});
+describe('registerFleetTools', () => {
+    it('registers all 6 expected tools', () => {
+        expect(tools.size).toBe(6);
+        expect([...tools.keys()].sort()).toEqual([
+            'forward-prompt',
+            'get-cost-report',
+            'get-task-status',
+            'list-fleet',
+            'stop-agent',
+            'submit-task',
+        ]);
+    });
+});
+describe('submit-task', () => {
+    it('creates a pending session and returns task info', async () => {
+        const handler = tools.get('submit-task');
+        vi.mocked(storeSessionState).mockResolvedValue({
+            linearSessionId: 'mcp-123-issue-1',
+            issueId: 'issue-1',
+            status: 'pending',
+            priority: 2,
+            workType: 'research',
+        });
+        const result = await handler({ issueId: 'issue-1', workType: 'research', priority: 2 });
+        const data = parseResult(result);
+        expect(data.submitted).toBe(true);
+        expect(data.issueId).toBe('issue-1');
+        expect(data.status).toBe('pending');
+        expect(data.workType).toBe('research');
+        expect(data.priority).toBe(2);
+        expect(storeSessionState).toHaveBeenCalledOnce();
+    });
+    it('defaults to development work type and priority 3', async () => {
+        const handler = tools.get('submit-task');
+        vi.mocked(storeSessionState).mockResolvedValue({
+            linearSessionId: 'mcp-123-issue-2',
+            issueId: 'issue-2',
+            status: 'pending',
+            priority: 3,
+            workType: 'development',
+        });
+        await handler({ issueId: 'issue-2' });
+        const callArgs = vi.mocked(storeSessionState).mock.calls[0][1];
+        expect(callArgs.workType).toBe('development');
+        expect(callArgs.priority).toBe(3);
+    });
+    it('returns error when storeSessionState throws', async () => {
+        const handler = tools.get('submit-task');
+        vi.mocked(storeSessionState).mockRejectedValue(new Error('Redis down'));
+        const result = await handler({ issueId: 'issue-1' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Redis down');
+    });
+});
+describe('get-task-status', () => {
+    it('returns session when found by session ID', async () => {
+        const handler = tools.get('get-task-status');
+        const session = makeSession();
+        vi.mocked(getSessionState).mockResolvedValue(session);
+        const result = await handler({ taskId: 'ses-123' });
+        const data = parseResult(result);
+        expect(data.linearSessionId).toBe('ses-123');
+        expect(result.isError).toBeUndefined();
+    });
+    it('falls back to issue-based lookup', async () => {
+        const handler = tools.get('get-task-status');
+        vi.mocked(getSessionState).mockResolvedValue(null);
+        vi.mocked(getSessionStateByIssue).mockResolvedValue(makeSession());
+        const result = await handler({ taskId: 'issue-abc' });
+        expect(getSessionStateByIssue).toHaveBeenCalledWith('issue-abc');
+        expect(result.isError).toBeUndefined();
+    });
+    it('returns error when task not found', async () => {
+        const handler = tools.get('get-task-status');
+        vi.mocked(getSessionState).mockResolvedValue(null);
+        vi.mocked(getSessionStateByIssue).mockResolvedValue(null);
+        const result = await handler({ taskId: 'unknown' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('No task found');
+    });
+});
+describe('list-fleet', () => {
+    it('returns all sessions when no filter', async () => {
+        const handler = tools.get('list-fleet');
+        const sessions = [makeSession(), makeSession({ linearSessionId: 'ses-456' })];
+        vi.mocked(getAllSessions).mockResolvedValue(sessions);
+        const result = await handler({});
+        const data = parseResult(result);
+        expect(data.total).toBe(2);
+        expect(data.returned).toBe(2);
+        expect(getAllSessions).toHaveBeenCalledOnce();
+    });
+    it('filters by status', async () => {
+        const handler = tools.get('list-fleet');
+        vi.mocked(getSessionsByStatus).mockResolvedValue([makeSession()]);
+        const result = await handler({ status: ['running'] });
+        const data = parseResult(result);
+        expect(getSessionsByStatus).toHaveBeenCalledWith(['running']);
+        expect(data.total).toBe(1);
+    });
+    it('respects limit parameter', async () => {
+        const handler = tools.get('list-fleet');
+        const sessions = Array.from({ length: 30 }, (_, i) => makeSession({ linearSessionId: `ses-${i}` }));
+        vi.mocked(getAllSessions).mockResolvedValue(sessions);
+        const result = await handler({ limit: 5 });
+        const data = parseResult(result);
+        expect(data.total).toBe(30);
+        expect(data.returned).toBe(5);
+    });
+    it('defaults limit to 20', async () => {
+        const handler = tools.get('list-fleet');
+        const sessions = Array.from({ length: 25 }, (_, i) => makeSession({ linearSessionId: `ses-${i}` }));
+        vi.mocked(getAllSessions).mockResolvedValue(sessions);
+        const result = await handler({});
+        const data = parseResult(result);
+        expect(data.returned).toBe(20);
+    });
+});
+describe('get-cost-report', () => {
+    it('returns single-task cost when taskId provided', async () => {
+        const handler = tools.get('get-cost-report');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ totalCostUsd: 1.23, inputTokens: 5000, outputTokens: 2000 }));
+        const result = await handler({ taskId: 'ses-123' });
+        const data = parseResult(result);
+        expect(data.totalCostUsd).toBe(1.23);
+        expect(data.inputTokens).toBe(5000);
+        expect(data.outputTokens).toBe(2000);
+    });
+    it('returns fleet-wide cost when no taskId', async () => {
+        const handler = tools.get('get-cost-report');
+        vi.mocked(getAllSessions).mockResolvedValue([
+            makeSession({ totalCostUsd: 1.0, inputTokens: 1000, outputTokens: 500 }),
+            makeSession({ totalCostUsd: 2.0, inputTokens: 2000, outputTokens: 1000 }),
+        ]);
+        const result = await handler({});
+        const data = parseResult(result);
+        expect(data.totalSessions).toBe(2);
+        expect(data.totalCostUsd).toBe(3.0);
+        expect(data.totalInputTokens).toBe(3000);
+        expect(data.totalOutputTokens).toBe(1500);
+    });
+    it('returns error when single task not found', async () => {
+        const handler = tools.get('get-cost-report');
+        vi.mocked(getSessionState).mockResolvedValue(null);
+        vi.mocked(getSessionStateByIssue).mockResolvedValue(null);
+        const result = await handler({ taskId: 'unknown' });
+        expect(result.isError).toBe(true);
+    });
+});
+describe('stop-agent', () => {
+    it('stops a running task', async () => {
+        const handler = tools.get('stop-agent');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'running' }));
+        vi.mocked(updateSessionStatus).mockResolvedValue(true);
+        const result = await handler({ taskId: 'ses-123' });
+        const data = parseResult(result);
+        expect(data.stopped).toBe(true);
+        expect(data.previousStatus).toBe('running');
+        expect(data.newStatus).toBe('stopped');
+        expect(updateSessionStatus).toHaveBeenCalledWith('ses-123', 'stopped');
+    });
+    it('stops a pending task', async () => {
+        const handler = tools.get('stop-agent');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'pending' }));
+        vi.mocked(updateSessionStatus).mockResolvedValue(true);
+        const result = await handler({ taskId: 'ses-123' });
+        const data = parseResult(result);
+        expect(data.stopped).toBe(true);
+        expect(data.previousStatus).toBe('pending');
+    });
+    it('rejects stopping a completed task', async () => {
+        const handler = tools.get('stop-agent');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'completed' }));
+        const result = await handler({ taskId: 'ses-123' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('cannot be stopped');
+    });
+    it('returns error when task not found', async () => {
+        const handler = tools.get('stop-agent');
+        vi.mocked(getSessionState).mockResolvedValue(null);
+        vi.mocked(getSessionStateByIssue).mockResolvedValue(null);
+        const result = await handler({ taskId: 'unknown' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('No task found');
+    });
+    it('returns error when Redis update fails', async () => {
+        const handler = tools.get('stop-agent');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'running' }));
+        vi.mocked(updateSessionStatus).mockResolvedValue(false);
+        const result = await handler({ taskId: 'ses-123' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Failed to update');
+    });
+});
+describe('forward-prompt', () => {
+    it('forwards a prompt to a running session', async () => {
+        const handler = tools.get('forward-prompt');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'running' }));
+        vi.mocked(storePendingPrompt).mockResolvedValue({
+            id: 'prm_123',
+            sessionId: 'ses-123',
+            issueId: 'issue-abc',
+            prompt: 'Please also fix the tests',
+            createdAt: Date.now(),
+        });
+        const result = await handler({ taskId: 'ses-123', message: 'Please also fix the tests' });
+        const data = parseResult(result);
+        expect(data.forwarded).toBe(true);
+        expect(data.promptId).toBe('prm_123');
+        expect(data.taskId).toBe('ses-123');
+        expect(storePendingPrompt).toHaveBeenCalledWith('ses-123', 'issue-abc', 'Please also fix the tests');
+    });
+    it('forwards a prompt to a claimed session', async () => {
+        const handler = tools.get('forward-prompt');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'claimed' }));
+        vi.mocked(storePendingPrompt).mockResolvedValue({
+            id: 'prm_456',
+            sessionId: 'ses-123',
+            issueId: 'issue-abc',
+            prompt: 'extra context',
+            createdAt: Date.now(),
+        });
+        const result = await handler({ taskId: 'ses-123', message: 'extra context' });
+        const data = parseResult(result);
+        expect(data.forwarded).toBe(true);
+        expect(data.sessionStatus).toBe('claimed');
+    });
+    it('falls back to issue-based lookup', async () => {
+        const handler = tools.get('forward-prompt');
+        vi.mocked(getSessionState).mockResolvedValue(null);
+        vi.mocked(getSessionStateByIssue).mockResolvedValue(makeSession());
+        vi.mocked(storePendingPrompt).mockResolvedValue({
+            id: 'prm_789',
+            sessionId: 'ses-123',
+            issueId: 'issue-abc',
+            prompt: 'msg',
+            createdAt: Date.now(),
+        });
+        const result = await handler({ taskId: 'issue-abc', message: 'msg' });
+        expect(getSessionStateByIssue).toHaveBeenCalledWith('issue-abc');
+        expect(result.isError).toBeUndefined();
+    });
+    it('rejects forwarding to a completed session', async () => {
+        const handler = tools.get('forward-prompt');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'completed' }));
+        const result = await handler({ taskId: 'ses-123', message: 'hello' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Prompts can only be forwarded to running or claimed');
+    });
+    it('rejects forwarding to a stopped session', async () => {
+        const handler = tools.get('forward-prompt');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'stopped' }));
+        const result = await handler({ taskId: 'ses-123', message: 'hello' });
+        expect(result.isError).toBe(true);
+    });
+    it('returns error when task not found', async () => {
+        const handler = tools.get('forward-prompt');
+        vi.mocked(getSessionState).mockResolvedValue(null);
+        vi.mocked(getSessionStateByIssue).mockResolvedValue(null);
+        const result = await handler({ taskId: 'unknown', message: 'hello' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('No task found');
+    });
+    it('returns error when storePendingPrompt fails', async () => {
+        const handler = tools.get('forward-prompt');
+        vi.mocked(getSessionState).mockResolvedValue(makeSession({ status: 'running' }));
+        vi.mocked(storePendingPrompt).mockResolvedValue(null);
+        const result = await handler({ taskId: 'ses-123', message: 'hello' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Failed to store pending prompt');
+    });
+});

package/dist/src/transport.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import http from 'node:http';
+export interface HttpTransportOptions {
+    port?: number;
+    host?: string;
+}
+export declare function startStdioTransport(server: McpServer): Promise<void>;
+export declare function startHttpTransport(server: McpServer, options?: HttpTransportOptions): Promise<http.Server>;
+//# sourceMappingURL=transport.d.ts.map

package/dist/src/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,IAAI,MAAM,WAAW,CAAA;AAG5B,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1E;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,EACjB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CA0CtB"}

package/dist/src/transport.js

@@ -0,0 +1,44 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import http from 'node:http';
+import { verifyMcpAuth, isMcpAuthConfigured } from './auth.js';
+export async function startStdioTransport(server) {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+export async function startHttpTransport(server, options = {}) {
+    const port = options.port ?? parseInt(process.env.MCP_PORT ?? '3100', 10);
+    const host = options.host ?? process.env.MCP_HOST ?? '0.0.0.0';
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => crypto.randomUUID() });
+    const httpServer = http.createServer(async (req, res) => {
+        // Health check endpoint
+        if (req.url === '/health' && req.method === 'GET') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', server: 'agentfactory-fleet', auth: isMcpAuthConfigured() }));
+            return;
+        }
+        // MCP endpoint — verify auth for non-health endpoints
+        if (req.url === '/mcp') {
+            const authResult = verifyMcpAuth(req.headers.authorization);
+            if (!authResult.authorized) {
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: authResult.error }));
+                return;
+            }
+            await transport.handleRequest(req, res);
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found. Use /mcp for MCP protocol or /health for health check.' }));
+    });
+    await server.connect(transport);
+    return new Promise((resolve) => {
+        httpServer.listen(port, host, () => {
+            console.log(`[mcp-server] AgentFactory Fleet MCP server listening on http://${host}:${port}`);
+            console.log(`[mcp-server] MCP endpoint: http://${host}:${port}/mcp`);
+            console.log(`[mcp-server] Health check: http://${host}:${port}/health`);
+            console.log(`[mcp-server] Auth: ${isMcpAuthConfigured() ? 'enabled' : 'disabled (dev mode)'}`);
+            resolve(httpServer);
+        });
+    });
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@renseiai/agentfactory-mcp-server",
+  "version": "0.8.0",
+  "type": "module",
+  "description": "MCP server exposing AgentFactory fleet capabilities to MCP-aware clients",
+  "author": "Rensei AI (https://rensei.ai)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/renseiai/agentfactory",
+    "directory": "packages/mcp-server"
+  },
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/src/index.d.ts",
+        "import": "./dist/src/index.js",
+        "default": "./dist/src/index.js"
+      }
+    },
+    "main": "./dist/src/index.js",
+    "types": "./dist/src/index.d.ts"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "bin": {
+    "af-mcp-server": "./dist/src/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@renseiai/agentfactory-server": "workspace:*",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.4",
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm clean && pnpm build"
+  }
+}