tempo-api-mcp 2.0.0 → 2.0.2

package/dist/tools/worklogs.js

@@ -1,290 +1,208 @@
-export const toolDefinitions = [
-    {
-        name: 'tempo_get_worklogs',
+import { z } from 'zod';
+export function register(server, client) {
+    server.registerTool('tempo_get_worklogs', {
         description: 'Retrieve a list of Tempo worklogs matching the given search parameters. Supports filtering by project, issue, date range, and more.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                projectId: { type: 'array', items: { type: 'integer' }, description: 'Filter by project ids' },
-                issueId: { type: 'array', items: { type: 'integer' }, description: 'Filter by issue ids' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-                updatedFrom: { type: 'string', description: 'Filter by update date/time (YYYY-MM-DD or YYYY-MM-DDTHH:mm:ssZ)' },
-                offset: { type: 'integer', description: 'Pagination offset (default 0)' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-                orderBy: { type: 'string', enum: ['ID', 'START_DATE_TIME', 'UPDATED'], description: 'Sort order (descending)' },
-            },
-            required: [],
+            projectId: z.array(z.number().int()).optional().describe('Filter by project ids'),
+            issueId: z.array(z.number().int()).optional().describe('Filter by issue ids'),
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
+            updatedFrom: z.string().optional().describe('Filter by update date/time (YYYY-MM-DD or YYYY-MM-DDTHH:mm:ssZ)'),
+            offset: z.number().int().optional().describe('Pagination offset (default 0)'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
+            orderBy: z.enum(['ID', 'START_DATE_TIME', 'UPDATED']).optional().describe('Sort order (descending)'),
         },
-    },
-    {
-        name: 'tempo_get_worklog',
+    }, async ({ projectId, issueId, from, to, updatedFrom, offset, limit, orderBy }) => {
+        const data = await client.request('GET', '/4/worklogs', undefined, {
+            projectId, issueId, from, to, updatedFrom, offset, limit, orderBy,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_worklog', {
         description: 'Retrieve a single Tempo worklog by its id.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'string', description: 'Worklog id' },
-            },
-            required: ['id'],
+            id: z.string().describe('Worklog id'),
         },
-    },
-    {
-        name: 'tempo_create_worklog',
+    }, async ({ id }) => {
+        const data = await client.request('GET', `/4/worklogs/${id}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_create_worklog', {
         description: 'Create a new Tempo worklog.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                authorAccountId: { type: 'string', description: 'Atlassian account id of the worklog author' },
-                issueId: { type: 'integer', description: 'Jira issue id to log time against' },
-                startDate: { type: 'string', description: 'Work date (YYYY-MM-DD)' },
-                timeSpentSeconds: { type: 'integer', description: 'Time spent in seconds (e.g. 3600 = 1 hour)' },
-                startTime: { type: 'string', description: 'Start time (HH:mm:ss)', pattern: '^([0-1]?[0-9]|2[0-3])(:[0-5][0-9])(:[0-5][0-9])$' },
-                description: { type: 'string', description: 'Description of work done' },
-                billableSeconds: { type: 'integer', description: 'Billable seconds (defaults to timeSpentSeconds)' },
-                remainingEstimateSeconds: { type: 'integer', description: 'Remaining estimate in seconds' },
-            },
-            required: ['authorAccountId', 'issueId', 'startDate', 'timeSpentSeconds'],
+            authorAccountId: z.string().describe('Atlassian account id of the worklog author'),
+            issueId: z.number().int().describe('Jira issue id to log time against'),
+            startDate: z.string().describe('Work date (YYYY-MM-DD)'),
+            timeSpentSeconds: z.number().int().describe('Time spent in seconds (e.g. 3600 = 1 hour)'),
+            startTime: z.string().regex(/^([0-1]?[0-9]|2[0-3])(:[0-5][0-9])(:[0-5][0-9])$/).optional().describe('Start time (HH:mm:ss)'),
+            description: z.string().optional().describe('Description of work done'),
+            billableSeconds: z.number().int().optional().describe('Billable seconds (defaults to timeSpentSeconds)'),
+            remainingEstimateSeconds: z.number().int().optional().describe('Remaining estimate in seconds'),
         },
-    },
-    {
-        name: 'tempo_update_worklog',
+    }, async ({ authorAccountId, issueId, startDate, timeSpentSeconds, startTime, description, billableSeconds, remainingEstimateSeconds }) => {
+        const body = { authorAccountId, issueId, startDate, timeSpentSeconds };
+        if (startTime !== undefined)
+            body.startTime = startTime;
+        if (description !== undefined)
+            body.description = description;
+        if (billableSeconds !== undefined)
+            body.billableSeconds = billableSeconds;
+        if (remainingEstimateSeconds !== undefined)
+            body.remainingEstimateSeconds = remainingEstimateSeconds;
+        const data = await client.request('POST', '/4/worklogs', body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_update_worklog', {
         description: 'Update an existing Tempo worklog by id.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'string', description: 'Worklog id' },
-                authorAccountId: { type: 'string', description: 'Atlassian account id of the worklog author' },
-                startDate: { type: 'string', description: 'Work date (YYYY-MM-DD)' },
-                timeSpentSeconds: { type: 'integer', description: 'Time spent in seconds' },
-                startTime: { type: 'string', description: 'Start time (HH:mm:ss)' },
-                description: { type: 'string', description: 'Description of work done' },
-                billableSeconds: { type: 'integer', description: 'Billable seconds' },
-                remainingEstimateSeconds: { type: 'integer', description: 'Remaining estimate in seconds' },
-            },
-            required: ['id', 'authorAccountId', 'startDate', 'timeSpentSeconds'],
+            id: z.string().describe('Worklog id'),
+            authorAccountId: z.string().describe('Atlassian account id of the worklog author'),
+            startDate: z.string().describe('Work date (YYYY-MM-DD)'),
+            timeSpentSeconds: z.number().int().describe('Time spent in seconds'),
+            startTime: z.string().optional().describe('Start time (HH:mm:ss)'),
+            description: z.string().optional().describe('Description of work done'),
+            billableSeconds: z.number().int().optional().describe('Billable seconds'),
+            remainingEstimateSeconds: z.number().int().optional().describe('Remaining estimate in seconds'),
         },
-    },
-    {
-        name: 'tempo_delete_worklog',
+    }, async ({ id, authorAccountId, startDate, timeSpentSeconds, startTime, description, billableSeconds, remainingEstimateSeconds }) => {
+        const body = { authorAccountId, startDate, timeSpentSeconds };
+        if (startTime !== undefined)
+            body.startTime = startTime;
+        if (description !== undefined)
+            body.description = description;
+        if (billableSeconds !== undefined)
+            body.billableSeconds = billableSeconds;
+        if (remainingEstimateSeconds !== undefined)
+            body.remainingEstimateSeconds = remainingEstimateSeconds;
+        const data = await client.request('PUT', `/4/worklogs/${id}`, body);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_delete_worklog', {
         description: 'Delete a Tempo worklog by id.',
         annotations: { readOnlyHint: false },
         inputSchema: {
-            type: 'object',
-            properties: {
-                id: { type: 'string', description: 'Worklog id' },
-                bypassPeriodClosuresAndApprovals: { type: 'boolean', description: 'Bypass period closures/approvals (requires Tempo Admin + Override Mode)' },
-            },
-            required: ['id'],
+            id: z.string().describe('Worklog id'),
+            bypassPeriodClosuresAndApprovals: z.boolean().optional().describe('Bypass period closures/approvals (requires Tempo Admin + Override Mode)'),
         },
-    },
-    {
-        name: 'tempo_search_worklogs',
+    }, async ({ id, bypassPeriodClosuresAndApprovals }) => {
+        await client.request('DELETE', `/4/worklogs/${id}`, undefined, {
+            bypassPeriodClosuresAndApprovals,
+        });
+        return { content: [{ type: 'text', text: `Worklog ${id} deleted successfully` }] };
+    });
+    server.registerTool('tempo_search_worklogs', {
         description: 'Search Tempo worklogs using a POST body with advanced filters (author ids, issue ids, project ids, date range).',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                authorIds: { type: 'array', items: { type: 'string' }, description: 'Atlassian account ids of worklog authors' },
-                issueIds: { type: 'array', items: { type: 'integer' }, description: 'Jira issue ids' },
-                projectIds: { type: 'array', items: { type: 'integer' }, description: 'Jira project ids' },
-                teamIds: { type: 'array', items: { type: 'integer' }, description: 'Tempo team ids' },
-                accountIds: { type: 'array', items: { type: 'string' }, description: 'Tempo account keys' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-                updatedFrom: { type: 'string', description: 'Filter by update date' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: [],
+            authorIds: z.array(z.string()).optional().describe('Atlassian account ids of worklog authors'),
+            issueIds: z.array(z.number().int()).optional().describe('Jira issue ids'),
+            projectIds: z.array(z.number().int()).optional().describe('Jira project ids'),
+            teamIds: z.array(z.number().int()).optional().describe('Tempo team ids'),
+            accountIds: z.array(z.string()).optional().describe('Tempo account keys'),
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
+            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 (default 50)'),
         },
-    },
-    {
-        name: 'tempo_get_worklogs_by_user',
+    }, async ({ authorIds, issueIds, projectIds, teamIds, accountIds, from, to, updatedFrom, offset, limit }) => {
+        const query = {};
+        if (offset !== undefined)
+            query.offset = offset;
+        if (limit !== undefined)
+            query.limit = limit;
+        const body = {};
+        if (authorIds)
+            body.authorIds = authorIds;
+        if (issueIds)
+            body.issueIds = issueIds;
+        if (projectIds)
+            body.projectIds = projectIds;
+        if (teamIds)
+            body.teamIds = teamIds;
+        if (accountIds)
+            body.accountIds = accountIds;
+        if (from)
+            body.from = from;
+        if (to)
+            body.to = to;
+        if (updatedFrom)
+            body.updatedFrom = updatedFrom;
+        const data = await client.request('POST', '/4/worklogs/search', body, query);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_worklogs_by_user', {
         description: 'Retrieve all Tempo worklogs for a specific user (Atlassian account id).',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                accountId: { type: 'string', description: 'Atlassian account id of the user' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: ['accountId'],
+            accountId: z.string().describe('Atlassian account id of the user'),
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_get_worklogs_by_project',
+    }, async ({ accountId, from, to, offset, limit }) => {
+        const data = await client.request('GET', `/4/worklogs/user/${accountId}`, undefined, { from, to, offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_worklogs_by_project', {
         description: 'Retrieve all Tempo worklogs for a specific Jira project.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                projectId: { type: 'integer', description: 'Jira project id' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: ['projectId'],
+            projectId: z.number().int().describe('Jira project id'),
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_get_worklogs_by_issue',
+    }, async ({ projectId, from, to, offset, limit }) => {
+        const data = await client.request('GET', `/4/worklogs/project/${projectId}`, undefined, { from, to, offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_worklogs_by_issue', {
         description: 'Retrieve all Tempo worklogs for a specific Jira issue.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                issueId: { type: 'integer', description: 'Jira issue id' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: ['issueId'],
+            issueId: z.number().int().describe('Jira issue id'),
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_get_worklogs_by_team',
+    }, async ({ issueId, from, to, offset, limit }) => {
+        const data = await client.request('GET', `/4/worklogs/issue/${issueId}`, undefined, { from, to, offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_worklogs_by_team', {
         description: 'Retrieve all Tempo worklogs for a specific Tempo team.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                teamId: { type: 'integer', description: 'Tempo team id' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: ['teamId'],
+            teamId: z.number().int().describe('Tempo team id'),
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-    {
-        name: 'tempo_get_worklogs_by_account',
+    }, async ({ teamId, from, to, offset, limit }) => {
+        const data = await client.request('GET', `/4/worklogs/team/${teamId}`, undefined, { from, to, offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('tempo_get_worklogs_by_account', {
         description: 'Retrieve all Tempo worklogs associated to a Tempo account key.',
         annotations: { readOnlyHint: true },
         inputSchema: {
-            type: 'object',
-            properties: {
-                accountKey: { type: 'string', description: 'Tempo account key (e.g. ACCOUNT-123)' },
-                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
-                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
-                offset: { type: 'integer', description: 'Pagination offset' },
-                limit: { type: 'integer', description: 'Max results (default 50)' },
-            },
-            required: ['accountKey'],
+            accountKey: z.string().describe('Tempo account key (e.g. ACCOUNT-123)'),
+            from: z.string().optional().describe('Start date (YYYY-MM-DD)'),
+            to: z.string().optional().describe('End date (YYYY-MM-DD)'),
+            offset: z.number().int().optional().describe('Pagination offset'),
+            limit: z.number().int().optional().describe('Max results (default 50)'),
         },
-    },
-];
-export async function handleTool(name, args, client) {
-    switch (name) {
-        case 'tempo_get_worklogs': {
-            const { projectId, issueId, from, to, updatedFrom, offset, limit, orderBy } = args;
-            const data = await client.request('GET', '/4/worklogs', undefined, {
-                projectId, issueId, from, to, updatedFrom, offset, limit, orderBy,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_worklog': {
-            const { id } = args;
-            const data = await client.request('GET', `/4/worklogs/${id}`);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_create_worklog': {
-            const { authorAccountId, issueId, startDate, timeSpentSeconds, startTime, description, billableSeconds, remainingEstimateSeconds } = args;
-            const body = { authorAccountId, issueId, startDate, timeSpentSeconds };
-            if (startTime !== undefined)
-                body.startTime = startTime;
-            if (description !== undefined)
-                body.description = description;
-            if (billableSeconds !== undefined)
-                body.billableSeconds = billableSeconds;
-            if (remainingEstimateSeconds !== undefined)
-                body.remainingEstimateSeconds = remainingEstimateSeconds;
-            const data = await client.request('POST', '/4/worklogs', body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_update_worklog': {
-            const { id, authorAccountId, startDate, timeSpentSeconds, startTime, description, billableSeconds, remainingEstimateSeconds } = args;
-            const body = { authorAccountId, startDate, timeSpentSeconds };
-            if (startTime !== undefined)
-                body.startTime = startTime;
-            if (description !== undefined)
-                body.description = description;
-            if (billableSeconds !== undefined)
-                body.billableSeconds = billableSeconds;
-            if (remainingEstimateSeconds !== undefined)
-                body.remainingEstimateSeconds = remainingEstimateSeconds;
-            const data = await client.request('PUT', `/4/worklogs/${id}`, body);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_delete_worklog': {
-            const { id, bypassPeriodClosuresAndApprovals } = args;
-            await client.request('DELETE', `/4/worklogs/${id}`, undefined, {
-                bypassPeriodClosuresAndApprovals,
-            });
-            return { content: [{ type: 'text', text: `Worklog ${id} deleted successfully` }] };
-        }
-        case 'tempo_search_worklogs': {
-            const { authorIds, issueIds, projectIds, teamIds, accountIds, from, to, updatedFrom, offset, limit } = args;
-            const query = {};
-            if (offset !== undefined)
-                query.offset = offset;
-            if (limit !== undefined)
-                query.limit = limit;
-            const body = {};
-            if (authorIds)
-                body.authorIds = authorIds;
-            if (issueIds)
-                body.issueIds = issueIds;
-            if (projectIds)
-                body.projectIds = projectIds;
-            if (teamIds)
-                body.teamIds = teamIds;
-            if (accountIds)
-                body.accountIds = accountIds;
-            if (from)
-                body.from = from;
-            if (to)
-                body.to = to;
-            if (updatedFrom)
-                body.updatedFrom = updatedFrom;
-            const data = await client.request('POST', '/4/worklogs/search', body, query);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_worklogs_by_user': {
-            const { accountId, from, to, offset, limit } = args;
-            const data = await client.request('GET', `/4/worklogs/user/${accountId}`, undefined, { from, to, offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_worklogs_by_project': {
-            const { projectId, from, to, offset, limit } = args;
-            const data = await client.request('GET', `/4/worklogs/project/${projectId}`, undefined, { from, to, offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_worklogs_by_issue': {
-            const { issueId, from, to, offset, limit } = args;
-            const data = await client.request('GET', `/4/worklogs/issue/${issueId}`, undefined, { from, to, offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_worklogs_by_team': {
-            const { teamId, from, to, offset, limit } = args;
-            const data = await client.request('GET', `/4/worklogs/team/${teamId}`, undefined, { from, to, offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        case 'tempo_get_worklogs_by_account': {
-            const { accountKey, from, to, offset, limit } = args;
-            const data = await client.request('GET', `/4/worklogs/account/${accountKey}`, undefined, { from, to, offset, limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
+    }, async ({ accountKey, from, to, offset, limit }) => {
+        const data = await client.request('GET', `/4/worklogs/account/${accountKey}`, undefined, { from, to, offset, limit });
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "tempo-api-mcp",
-  "version": "2.0.0",
-  "description": "Tempo API MCP server for Claude — developed and maintained by AI (Claude Sonnet 4.6)",
-  "author": "Claude Sonnet 4.6 (AI) <https://www.anthropic.com/claude>",
+  "version": "2.0.2",
+  "mcpName": "io.github.chrischall/tempo-api-mcp",
+  "description": "Tempo API MCP server for Claude — developed and maintained by AI (Claude Code)",
+  "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/chrischall/tempo-api-mcp.git"
@@ -13,7 +14,8 @@
   },
   "files": [
     "dist",
-    "SKILL.md"
+    "SKILL.md",
+    "server.json"
   ],
   "scripts": {
     "build": "tsc && npm run bundle",
@@ -25,12 +27,13 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "dotenv": "^17.4.0"
+    "dotenv": "^17.4.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^25.5.2",
     "@vitest/coverage-v8": "^4.1.2",
-    "esbuild": "^0.27.0",
+    "esbuild": "^0.28.0",
     "typescript": "^6.0.2",
     "vitest": "^4.1.2"
   }

package/server.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.chrischall/tempo-api-mcp",
+  "description": "Tempo time-tracking for Claude — worklogs, plans, and timesheet approvals",
+  "repository": {
+    "url": "https://github.com/chrischall/tempo-api-mcp",
+    "source": "github"
+  },
+  "version": "2.0.2",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "tempo-api-mcp",
+      "version": "2.0.2",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "name": "TEMPO_API_TOKEN",
+          "description": "Your Tempo API token (Settings → API integration in your Tempo workspace)",
+          "isRequired": true,
+          "format": "string",
+          "isSecret": true
+        }
+      ]
+    }
+  ]
+}