tempo-api-mcp 2.0.0 → 2.0.2

package/dist/client.js

@@ -4,16 +4,34 @@ import { fileURLToPath } from 'url';
 try {
     const { config } = await import('dotenv');
     const __dirname = dirname(fileURLToPath(import.meta.url));
-    config({ path: join(__dirname, '..', '.env'), override: false });
+    config({ path: join(__dirname, '..', '.env'), override: false, quiet: true });
 }
 catch {
     // not available — rely on process.env (mcpb sets credentials via mcp_config.env)
 }
+/**
+ * Read an env var, trim whitespace, and treat as unset if blank or if the value
+ * looks like an unsubstituted shell placeholder (e.g. `${FOO}`) — defends
+ * against MCP hosts that pass .mcp.json env blocks through unexpanded.
+ */
+function readVar(key) {
+    const raw = process.env[key];
+    if (typeof raw !== 'string')
+        return undefined;
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    if (trimmed === 'undefined' || trimmed === 'null')
+        return undefined;
+    if (/^\$\{[^}]*\}$/.test(trimmed))
+        return undefined;
+    return trimmed;
+}
 const BASE_URL = 'https://api.tempo.io';
 export class TempoClient {
     apiToken;
     constructor() {
-        const token = process.env.TEMPO_API_TOKEN;
+        const token = readVar('TEMPO_API_TOKEN');
         if (!token)
             throw new Error('TEMPO_API_TOKEN environment variable is required');
         this.apiToken = token;

package/dist/index.js

@@ -1,54 +1,19 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { TempoClient } from './client.js';
-import { toolDefinitions as worklogTools, handleTool as handleWorklogs } from './tools/worklogs.js';
-import { toolDefinitions as planTools, handleTool as handlePlans } from './tools/plans.js';
-import { toolDefinitions as teamTools, handleTool as handleTeams } from './tools/teams.js';
-import { toolDefinitions as accountTools, handleTool as handleAccounts } from './tools/accounts.js';
-import { toolDefinitions as projectTools, handleTool as handleProjects } from './tools/projects.js';
+import { register as registerWorklogs } from './tools/worklogs.js';
+import { register as registerPlans } from './tools/plans.js';
+import { register as registerTeams } from './tools/teams.js';
+import { register as registerAccounts } from './tools/accounts.js';
+import { register as registerProjects } from './tools/projects.js';
 const client = new TempoClient();
-const allTools = [
-    ...worklogTools,
-    ...planTools,
-    ...teamTools,
-    ...accountTools,
-    ...projectTools,
-];
-const handlers = {};
-for (const tool of worklogTools)
-    handlers[tool.name] = (n, a) => handleWorklogs(n, a, client);
-for (const tool of planTools)
-    handlers[tool.name] = (n, a) => handlePlans(n, a, client);
-for (const tool of teamTools)
-    handlers[tool.name] = (n, a) => handleTeams(n, a, client);
-for (const tool of accountTools)
-    handlers[tool.name] = (n, a) => handleAccounts(n, a, client);
-for (const tool of projectTools)
-    handlers[tool.name] = (n, a) => handleProjects(n, a, client);
-const server = new Server({ name: 'tempo-api-mcp', version: '2.0.0' }, { capabilities: { tools: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: allTools }));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args = {} } = request.params;
-    const handler = handlers[name];
-    if (!handler) {
-        return {
-            content: [{ type: 'text', text: `Unknown tool: ${name}` }],
-            isError: true,
-        };
-    }
-    try {
-        return await handler(name, args);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: 'text', text: `Error: ${message}` }],
-            isError: true,
-        };
-    }
-});
+const server = new McpServer({ name: 'tempo-api-mcp', version: '2.0.2' });
+registerWorklogs(server, client);
+registerPlans(server, client);
+registerTeams(server, client);
+registerAccounts(server, client);
+registerProjects(server, client);
 console.error('[tempo-api-mcp] This project was developed and is maintained by AI (Claude Sonnet 4.6). Use at your own discretion.');
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/tools/accounts.js

@@ -1,183 +1,126 @@
-export const toolDefinitions = [
-    {
-        name: 'tempo_get_accounts',
+import { z } from 'zod';
+function buildAccountBody(args) {
+    const body = { key: args.key, name: args.name };
+    if (args.status !== undefined)
+        body.status = args.status;
+    if (args.leadAccountId !== undefined)
+        body.leadAccountId = args.leadAccountId;
+    if (args.categoryKey !== undefined)
+        body.categoryKey = args.categoryKey;
+    if (args.contactAccountId !== undefined)
+        body.contactAccountId = args.contactAccountId;
+    if (args.externalContactName !== undefined)
+        body.externalContactName = args.externalContactName;
+    if (args.monthlyBudget !== undefined)
+        body.monthlyBudget = args.monthlyBudget;
+    return body;
+}
+export function register(server, client) {
+    server.registerTool('tempo_get_accounts', {
         description: 'Retrieve a list of all Tempo accounts (OPEN and CLOSED).',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: [],
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_get_account',
+    }, async ({ offset, limit }) => {
+        const data = await client.request('GET', '/4/accounts', undefined, { offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_account', {
         description: 'Retrieve a single Tempo account by its key.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string', description: 'Account key (e.g. ACCOUNT-123)' },
-            },
-            required: ['key'],
+            key: z.string().describe('Account key (e.g. ACCOUNT-123)'),
         },
-    },
-    {
-        name: 'tempo_search_accounts',
+    }, async ({ key }) => {
+        const data = await client.request('GET', `/4/accounts/${key}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_search_accounts', {
         description: 'Search Tempo accounts with advanced filters (status, category, project).',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'Text search across account name and key' },
-                statusList: {
-                    type: 'array',
-                    items: { type: 'string', enum: ['OPEN', 'CLOSED', 'ARCHIVED'] },
-                    description: 'Filter by account status',
-                },
-                accountCategoryKeys: { type: 'array', items: { type: 'string' }, description: 'Filter by account category keys' },
-                projectKeys: { type: 'array', items: { type: 'string' }, description: 'Filter by associated Jira project keys' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: [],
+            query: z.string().optional().describe('Text search across account name and key'),
+            statusList: z.array(z.enum(['OPEN', 'CLOSED', 'ARCHIVED'])).optional().describe('Filter by account status'),
+            accountCategoryKeys: z.array(z.string()).optional().describe('Filter by account category keys'),
+            projectKeys: z.array(z.string()).optional().describe('Filter by associated Jira project keys'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_create_account',
+    }, async ({ query, statusList, accountCategoryKeys, projectKeys, offset, limit }) => {
+        const qs = {};
+        if (offset !== undefined)
+            qs.offset = offset;
+        if (limit !== undefined)
+            qs.limit = limit;
+        const body = {};
+        if (query)
+            body.query = query;
+        if (statusList)
+            body.statusList = statusList;
+        if (accountCategoryKeys)
+            body.accountCategoryKeys = accountCategoryKeys;
+        if (projectKeys)
+            body.projectKeys = projectKeys;
+        const data = await client.request('POST', '/4/accounts/search', body, qs);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_create_account', {
         description: 'Create a new Tempo account.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string', description: 'Unique account key' },
-                name: { type: 'string', description: 'Account name' },
-                status: { type: 'string', enum: ['OPEN', 'CLOSED', 'ARCHIVED'], description: 'Account status (default OPEN)' },
-                leadAccountId: { type: 'string', description: 'Atlassian account id of the account lead' },
-                categoryKey: { type: 'string', description: 'Account category key' },
-                contactAccountId: { type: 'string', description: 'Atlassian account id of the contact person' },
-                externalContactName: { type: 'string', description: 'Name of external contact' },
-                monthlyBudget: { type: 'integer', description: 'Monthly budget in seconds' },
-            },
-            required: ['key', 'name'],
+            key: z.string().describe('Unique account key'),
+            name: z.string().describe('Account name'),
+            status: z.enum(['OPEN', 'CLOSED', 'ARCHIVED']).optional().describe('Account status (default OPEN)'),
+            leadAccountId: z.string().optional().describe('Atlassian account id of the account lead'),
+            categoryKey: z.string().optional().describe('Account category key'),
+            contactAccountId: z.string().optional().describe('Atlassian account id of the contact person'),
+            externalContactName: z.string().optional().describe('Name of external contact'),
+            monthlyBudget: z.number().int().optional().describe('Monthly budget in seconds'),
         },
-    },
-    {
-        name: 'tempo_update_account',
+    }, async (args) => {
+        const body = buildAccountBody(args);
+        const data = await client.request('POST', '/4/accounts', body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_update_account', {
         description: 'Update an existing Tempo account by its key.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string', description: 'Account key to update' },
-                name: { type: 'string', description: 'Account name' },
-                status: { type: 'string', enum: ['OPEN', 'CLOSED', 'ARCHIVED'], description: 'Account status' },
-                leadAccountId: { type: 'string', description: 'Atlassian account id of the account lead' },
-                categoryKey: { type: 'string', description: 'Account category key' },
-                contactAccountId: { type: 'string', description: 'Atlassian account id of the contact person' },
-                externalContactName: { type: 'string', description: 'Name of external contact' },
-                monthlyBudget: { type: 'integer', description: 'Monthly budget in seconds' },
-            },
-            required: ['key', 'name'],
+            key: z.string().describe('Account key to update'),
+            name: z.string().describe('Account name'),
+            status: z.enum(['OPEN', 'CLOSED', 'ARCHIVED']).optional().describe('Account status'),
+            leadAccountId: z.string().optional().describe('Atlassian account id of the account lead'),
+            categoryKey: z.string().optional().describe('Account category key'),
+            contactAccountId: z.string().optional().describe('Atlassian account id of the contact person'),
+            externalContactName: z.string().optional().describe('Name of external contact'),
+            monthlyBudget: z.number().int().optional().describe('Monthly budget in seconds'),
         },
-    },
-    {
-        name: 'tempo_delete_account',
+    }, async ({ key, ...rest }) => {
+        const body = buildAccountBody({ key, ...rest });
+        const data = await client.request('PUT', `/4/accounts/${key}`, body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_delete_account', {
         description: 'Delete a Tempo account by its key.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string', description: 'Account key to delete' },
-            },
-            required: ['key'],
+            key: z.string().describe('Account key to delete'),
         },
-    },
-    {
-        name: 'tempo_get_account_categories',
+    }, async ({ key }) => {
+        await client.request('DELETE', `/4/accounts/${key}`);
+        return { content: [{ type: 'text', text: `Account ${key} deleted successfully` }] };
+    });
+    server.registerTool('tempo_get_account_categories', {
         description: 'Retrieve all Tempo account categories.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results' },
-            },
-            required: [],
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results'),
         },
-    },
-];
-function buildAccountBody(args) {
-    const body = { key: args.key, name: args.name };
-    if (args.status !== undefined)
-        body.status = args.status;
-    if (args.leadAccountId !== undefined)
-        body.leadAccountId = args.leadAccountId;
-    if (args.categoryKey !== undefined)
-        body.categoryKey = args.categoryKey;
-    if (args.contactAccountId !== undefined)
-        body.contactAccountId = args.contactAccountId;
-    if (args.externalContactName !== undefined)
-        body.externalContactName = args.externalContactName;
-    if (args.monthlyBudget !== undefined)
-        body.monthlyBudget = args.monthlyBudget;
-    return body;
-}
-export async function handleTool(name, args, client) {
-    switch (name) {
-        case 'tempo_get_accounts': {
-            const { offset, limit } = args;
-            const data = await client.request('GET', '/4/accounts', undefined, { offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_account': {
-            const { key } = args;
-            const data = await client.request('GET', `/4/accounts/${key}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_search_accounts': {
-            const { query, statusList, accountCategoryKeys, projectKeys, offset, limit } = args;
-            const qs = {};
-            if (offset !== undefined)
-                qs.offset = offset;
-            if (limit !== undefined)
-                qs.limit = limit;
-            const body = {};
-            if (query)
-                body.query = query;
-            if (statusList)
-                body.statusList = statusList;
-            if (accountCategoryKeys)
-                body.accountCategoryKeys = accountCategoryKeys;
-            if (projectKeys)
-                body.projectKeys = projectKeys;
-            const data = await client.request('POST', '/4/accounts/search', body, qs);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_create_account': {
-            const body = buildAccountBody(args);
-            const data = await client.request('POST', '/4/accounts', body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_update_account': {
-            const { key, ...rest } = args;
-            const body = buildAccountBody({ key, ...rest });
-            const data = await client.request('PUT', `/4/accounts/${key}`, body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_delete_account': {
-            const { key } = args;
-            await client.request('DELETE', `/4/accounts/${key}`);
-            return { content: [{ type: 'text', text: `Account ${key} deleted successfully` }] };
-        }
-        case 'tempo_get_account_categories': {
-            const { offset, limit } = args;
-            const data = await client.request('GET', '/4/account-categories', undefined, { offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
+    }, async ({ offset, limit }) => {
+        const data = await client.request('GET', '/4/account-categories', undefined, { offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }

package/dist/tools/plans.js

@@ -1,104 +1,4 @@
-export const toolDefinitions = [
-    {
-        name: 'tempo_get_plans',
-        description: 'Retrieve a list of Tempo plans (resource allocations) matching the given parameters. Requires from and to dates.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            type: 'object',
-            properties: {
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD) — required' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD) — required' },
-                accountIds: { type: 'array', items: { type: 'string' }, description: 'Filter by user account ids' },
-                assigneeTypes: { type: 'array', items: { type: 'string', enum: ['USER', 'GENERIC'] }, description: 'Filter by assignee type' },
-                genericResourceIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by generic resource ids' },
-                issueIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by Jira issue ids' },
-                projectIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by Jira project ids' },
-                planIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by specific plan ids' },
-                planItemTypes: { type: 'array', items: { type: 'string', enum: ['ISSUE', 'PROJECT'] }, description: 'Filter by plan item type' },
-                plannedTimeBreakdown: { type: 'array', items: { type: 'string', enum: ['DAILY', 'PERIOD'] }, description: 'Time breakdown granularity' },
-                updatedFrom: { type: 'string', description: 'Filter by update date' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (max 5000)' },
-            },
-            required: ['from', 'to'],
-        },
-    },
-    {
-        name: 'tempo_get_plan',
-        description: 'Retrieve a single Tempo plan (resource allocation) by id.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Plan id' },
-            },
-            required: ['id'],
-        },
-    },
-    {
-        name: 'tempo_create_plan',
-        description: 'Create a new Tempo plan (resource allocation) for a user or generic resource against an issue or project.',
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            type: 'object',
-            properties: {
-                assigneeId: { type: 'string', description: 'Atlassian account id (for USER) or generic resource id (for GENERIC)' },
-                assigneeType: { type: 'string', enum: ['USER', 'GENERIC'], description: 'Type of assignee' },
-                planItemId: { type: 'string', description: 'Id of the issue or project to plan against' },
-                planItemType: { type: 'string', enum: ['ISSUE', 'PROJECT'], description: 'Type of plan item' },
-                startDate: { type: 'string', description: 'Plan start date (YYYY-MM-DD)' },
-                endDate: { type: 'string', description: 'Plan end date (YYYY-MM-DD)' },
-                plannedSeconds: { type: 'integer', description: 'Total seconds planned (for TOTAL_SECONDS persistence type)' },
-                plannedSecondsPerDay: { type: 'integer', description: 'Seconds planned per day (for SECONDS_PER_DAY persistence type)' },
-                effortPersistenceType: { type: 'string', enum: ['SECONDS_PER_DAY', 'TOTAL_SECONDS'], description: 'How effort is distributed' },
-                description: { type: 'string', description: 'Plan description' },
-                startTime: { type: 'string', description: 'Start time (HH:mm)', pattern: '^([0-1]?[0-9]|2[0-3])(:[0-5][0-9])$' },
-                includeNonWorkingDays: { type: 'boolean', description: 'Include non-working days in plan' },
-                rule: { type: 'string', enum: ['NEVER', 'WEEKLY', 'BI_WEEKLY', 'MONTHLY'], description: 'Recurrence rule' },
-                recurrenceEndDate: { type: 'string', description: 'End date for recurrence (YYYY-MM-DD)' },
-            },
-            required: ['assigneeId', 'assigneeType', 'planItemId', 'planItemType', 'startDate', 'endDate'],
-        },
-    },
-    {
-        name: 'tempo_update_plan',
-        description: 'Update an existing Tempo plan (resource allocation) by id.',
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Plan id' },
-                assigneeId: { type: 'string', description: 'Atlassian account id or generic resource id' },
-                assigneeType: { type: 'string', enum: ['USER', 'GENERIC'], description: 'Type of assignee' },
-                planItemId: { type: 'string', description: 'Id of the issue or project' },
-                planItemType: { type: 'string', enum: ['ISSUE', 'PROJECT'], description: 'Type of plan item' },
-                startDate: { type: 'string', description: 'Plan start date (YYYY-MM-DD)' },
-                endDate: { type: 'string', description: 'Plan end date (YYYY-MM-DD)' },
-                plannedSeconds: { type: 'integer', description: 'Total seconds planned' },
-                plannedSecondsPerDay: { type: 'integer', description: 'Seconds planned per day' },
-                effortPersistenceType: { type: 'string', enum: ['SECONDS_PER_DAY', 'TOTAL_SECONDS'], description: 'How effort is distributed' },
-                description: { type: 'string', description: 'Plan description' },
-                startTime: { type: 'string', description: 'Start time (HH:mm)' },
-                includeNonWorkingDays: { type: 'boolean', description: 'Include non-working days in plan' },
-                rule: { type: 'string', enum: ['NEVER', 'WEEKLY', 'BI_WEEKLY', 'MONTHLY'], description: 'Recurrence rule' },
-                recurrenceEndDate: { type: 'string', description: 'End date for recurrence' },
-            },
-            required: ['id', 'assigneeId', 'assigneeType', 'planItemId', 'planItemType', 'startDate', 'endDate'],
-        },
-    },
-    {
-        name: 'tempo_delete_plan',
-        description: 'Delete a Tempo plan (resource allocation) by id.',
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'integer', description: 'Plan id' },
-            },
-            required: ['id'],
-        },
-    },
-];
+import { z } from 'zod';
 function buildPlanBody(args) {
     const body = {
         assigneeId: args.assigneeId,
@@ -126,37 +26,84 @@ function buildPlanBody(args) {
         body.recurrenceEndDate = args.recurrenceEndDate;
     return body;
 }
-export async function handleTool(name, args, client) {
-    switch (name) {
-        case 'tempo_get_plans': {
-            const { from, to, accountIds, assigneeTypes, genericResourceIds, issueIds, projectIds, planIds, planItemTypes, plannedTimeBreakdown, updatedFrom, offset, limit } = args;
-            const data = await client.request('GET', '/4/plans', undefined, {
-                from, to, accountIds, assigneeTypes, genericResourceIds, issueIds, projectIds, planIds, planItemTypes, plannedTimeBreakdown, updatedFrom, offset, limit,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_plan': {
-            const { id } = args;
-            const data = await client.request('GET', `/4/plans/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_create_plan': {
-            const body = buildPlanBody(args);
-            const data = await client.request('POST', '/4/plans', body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_update_plan': {
-            const { id, ...rest } = args;
-            const body = buildPlanBody(rest);
-            const data = await client.request('PUT', `/4/plans/${id}`, body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_delete_plan': {
-            const { id } = args;
-            await client.request('DELETE', `/4/plans/${id}`);
-            return { content: [{ type: 'text', text: `Plan ${id} deleted successfully` }] };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
+const planFields = {
+    assigneeId: z.string().describe('Atlassian account id (for USER) or generic resource id (for GENERIC)'),
+    assigneeType: z.enum(['USER', 'GENERIC']).describe('Type of assignee'),
+    planItemId: z.string().describe('Id of the issue or project to plan against'),
+    planItemType: z.enum(['ISSUE', 'PROJECT']).describe('Type of plan item'),
+    startDate: z.string().describe('Plan start date (YYYY-MM-DD)'),
+    endDate: z.string().describe('Plan end date (YYYY-MM-DD)'),
+    plannedSeconds: z.number().int().optional().describe('Total seconds planned (for TOTAL_SECONDS persistence type)'),
+    plannedSecondsPerDay: z.number().int().optional().describe('Seconds planned per day (for SECONDS_PER_DAY persistence type)'),
+    effortPersistenceType: z.enum(['SECONDS_PER_DAY', 'TOTAL_SECONDS']).optional().describe('How effort is distributed'),
+    description: z.string().optional().describe('Plan description'),
+    startTime: z.string().regex(/^([0-1]?[0-9]|2[0-3])(:[0-5][0-9])$/).optional().describe('Start time (HH:mm)'),
+    includeNonWorkingDays: z.boolean().optional().describe('Include non-working days in plan'),
+    rule: z.enum(['NEVER', 'WEEKLY', 'BI_WEEKLY', 'MONTHLY']).optional().describe('Recurrence rule'),
+    recurrenceEndDate: z.string().optional().describe('End date for recurrence (YYYY-MM-DD)'),
+};
+export function register(server, client) {
+    server.registerTool('tempo_get_plans', {
+        description: 'Retrieve a list of Tempo plans (resource allocations) matching the given parameters. Requires from and to dates.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            from: z.string().describe('Start date (YYYY-MM-DD) — required'),
+            to: z.string().describe('End date (YYYY-MM-DD) — required'),
+            accountIds: z.array(z.string()).optional().describe('Filter by user account ids'),
+            assigneeTypes: z.array(z.enum(['USER', 'GENERIC'])).optional().describe('Filter by assignee type'),
+            genericResourceIds: z.array(z.number().int()).optional().describe('Filter by generic resource ids'),
+            issueIds: z.array(z.number().int()).optional().describe('Filter by Jira issue ids'),
+            projectIds: z.array(z.number().int()).optional().describe('Filter by Jira project ids'),
+            planIds: z.array(z.number().int()).optional().describe('Filter by specific plan ids'),
+            planItemTypes: z.array(z.enum(['ISSUE', 'PROJECT'])).optional().describe('Filter by plan item type'),
+            plannedTimeBreakdown: z.array(z.enum(['DAILY', 'PERIOD'])).optional().describe('Time breakdown granularity'),
+            updatedFrom: z.string().optional().describe('Filter by update date'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (max 5000)'),
+        },
+    }, async (args) => {
+        const data = await client.request('GET', '/4/plans', undefined, args);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_plan', {
+        description: 'Retrieve a single Tempo plan (resource allocation) by id.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            id: z.number().int().describe('Plan id'),
+        },
+    }, async ({ id }) => {
+        const data = await client.request('GET', `/4/plans/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_create_plan', {
+        description: 'Create a new Tempo plan (resource allocation) for a user or generic resource against an issue or project.',
+        annotations: { readOnlyHint: false },
+        inputSchema: planFields,
+    }, async (args) => {
+        const body = buildPlanBody(args);
+        const data = await client.request('POST', '/4/plans', body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_update_plan', {
+        description: 'Update an existing Tempo plan (resource allocation) by id.',
+        annotations: { readOnlyHint: false },
+        inputSchema: {
+            id: z.number().int().describe('Plan id'),
+            ...planFields,
+        },
+    }, async ({ id, ...rest }) => {
+        const body = buildPlanBody(rest);
+        const data = await client.request('PUT', `/4/plans/${id}`, body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_delete_plan', {
+        description: 'Delete a Tempo plan (resource allocation) by id.',
+        annotations: { readOnlyHint: false },
+        inputSchema: {
+            id: z.number().int().describe('Plan id'),
+        },
+    }, async ({ id }) => {
+        await client.request('DELETE', `/4/plans/${id}`);
+        return { content: [{ type: 'text', text: `Plan ${id} deleted successfully` }] };
+    });
 }