tempo-api-mcp 1.0.0

package/dist/client.js

@@ -0,0 +1,74 @@
+import { config as loadDotenv } from 'dotenv';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+loadDotenv({ path: join(__dirname, '..', '.env'), override: false, quiet: true });
+const BASE_URL = 'https://api.tempo.io';
+export class TempoClient {
+    apiToken;
+    constructor() {
+        const token = process.env.TEMPO_API_TOKEN;
+        if (!token)
+            throw new Error('TEMPO_API_TOKEN environment variable is required');
+        this.apiToken = token;
+    }
+    async request(method, path, body, queryParams) {
+        return this.doRequest(method, path, body, queryParams, false);
+    }
+    async doRequest(method, path, body, queryParams, isRetry) {
+        const headers = {
+            Authorization: `Bearer ${this.apiToken}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        };
+        let url = `${BASE_URL}${path}`;
+        if (queryParams) {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(queryParams)) {
+                if (value === undefined || value === null)
+                    continue;
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        params.append(key, String(item));
+                    }
+                }
+                else {
+                    params.set(key, String(value));
+                }
+            }
+            const qs = params.toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        const response = await fetch(url, {
+            method,
+            headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        if (response.status === 401) {
+            throw new Error('TEMPO_API_TOKEN is invalid or expired');
+        }
+        if (response.status === 429) {
+            if (!isRetry) {
+                await new Promise((r) => setTimeout(r, 2000));
+                return this.doRequest(method, path, body, queryParams, true);
+            }
+            throw new Error('Rate limited by Tempo API');
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        if (!response.ok) {
+            let errorText;
+            try {
+                const errorBody = await response.json();
+                errorText = errorBody.message ?? JSON.stringify(errorBody);
+            }
+            catch {
+                errorText = response.statusText;
+            }
+            throw new Error(`Tempo API error: ${response.status} ${errorText} for ${method} ${path}`);
+        }
+        return response.json();
+    }
+}

package/dist/index.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.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';
+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: '1.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,
+        };
+    }
+});
+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

@@ -0,0 +1,183 @@
+export const toolDefinitions = [
+    {
+        name: '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: [],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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: [],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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: [],
+        },
+    },
+];
+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}`);
+    }
+}

package/dist/tools/plans.js

@@ -0,0 +1,162 @@
+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'],
+        },
+    },
+];
+function buildPlanBody(args) {
+    const body = {
+        assigneeId: args.assigneeId,
+        assigneeType: args.assigneeType,
+        planItemId: args.planItemId,
+        planItemType: args.planItemType,
+        startDate: args.startDate,
+        endDate: args.endDate,
+    };
+    if (args.plannedSeconds !== undefined)
+        body.plannedSeconds = args.plannedSeconds;
+    if (args.plannedSecondsPerDay !== undefined)
+        body.plannedSecondsPerDay = args.plannedSecondsPerDay;
+    if (args.effortPersistenceType !== undefined)
+        body.effortPersistenceType = args.effortPersistenceType;
+    if (args.description !== undefined)
+        body.description = args.description;
+    if (args.startTime !== undefined)
+        body.startTime = args.startTime;
+    if (args.includeNonWorkingDays !== undefined)
+        body.includeNonWorkingDays = args.includeNonWorkingDays;
+    if (args.rule !== undefined)
+        body.rule = args.rule;
+    if (args.recurrenceEndDate !== undefined)
+        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}`);
+    }
+}

package/dist/tools/projects.js

@@ -0,0 +1,203 @@
+export const toolDefinitions = [
+    {
+        name: 'tempo_get_projects',
+        description: 'Retrieve a paginated list of all Tempo Financial Manager projects.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                offset: { type: 'integer', description: 'Pagination offset' },
+                limit: { type: 'integer', description: 'Max results (default 50)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'tempo_get_project',
+        description: 'Retrieve a single Tempo Financial Manager project by id.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Project id' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'tempo_get_timesheet_approval_status',
+        description: 'Retrieve the current timesheet approval status for a user in the given period.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                accountId: { type: 'string', description: 'Atlassian account id of the user' },
+                from: { type: 'string', description: 'Period start date (YYYY-MM-DD)' },
+                to: { type: 'string', description: 'Period end date (YYYY-MM-DD)' },
+            },
+            required: ['accountId'],
+        },
+    },
+    {
+        name: 'tempo_get_timesheet_approvals_waiting',
+        description: 'Retrieve all timesheets that are currently waiting for approval.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                offset: { type: 'integer', description: 'Pagination offset' },
+                limit: { type: 'integer', description: 'Max results' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'tempo_search_timesheet_approval_logs',
+        description: 'Search timesheet approval audit logs.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                accountIds: { type: 'array', items: { type: 'string' }, description: 'Filter by Atlassian account ids' },
+                reviewerIds: { type: 'array', items: { type: 'string' }, description: 'Filter by reviewer account ids' },
+                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' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'tempo_get_periods',
+        description: 'Retrieve Tempo period definitions (used for timesheet approval cycles).',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
+                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'tempo_get_user_schedule',
+        description: 'Retrieve the work schedule for a user, including planned working hours per day.',
+        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)' },
+            },
+            required: ['accountId', 'from', 'to'],
+        },
+    },
+    {
+        name: 'tempo_get_global_configuration',
+        description: 'Retrieve the global Tempo configuration settings.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'tempo_get_work_attributes',
+        description: 'Retrieve all Tempo work attributes (custom fields on worklogs).',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                offset: { type: 'integer', description: 'Pagination offset' },
+                limit: { type: 'integer', description: 'Max results' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'tempo_get_roles',
+        description: 'Retrieve all Tempo roles.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                offset: { type: 'integer', description: 'Pagination offset' },
+                limit: { type: 'integer', description: 'Max results' },
+            },
+            required: [],
+        },
+    },
+];
+export async function handleTool(name, args, client) {
+    switch (name) {
+        case 'tempo_get_projects': {
+            const { offset, limit } = args;
+            const data = await client.request('GET', '/4/projects', undefined, { offset, limit });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_project': {
+            const { id } = args;
+            const data = await client.request('GET', `/4/projects/${id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_timesheet_approval_status': {
+            const { accountId, from, to } = args;
+            const data = await client.request('GET', `/4/timesheet-approvals/user/${accountId}`, undefined, { from, to });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_timesheet_approvals_waiting': {
+            const { offset, limit } = args;
+            const data = await client.request('GET', '/4/timesheet-approvals/waiting', undefined, { offset, limit });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_search_timesheet_approval_logs': {
+            const { accountIds, reviewerIds, from, to, offset, limit } = args;
+            const qs = {};
+            if (offset !== undefined)
+                qs.offset = offset;
+            if (limit !== undefined)
+                qs.limit = limit;
+            const body = {};
+            if (accountIds)
+                body.accountIds = accountIds;
+            if (reviewerIds)
+                body.reviewerIds = reviewerIds;
+            if (from)
+                body.from = from;
+            if (to)
+                body.to = to;
+            const data = await client.request('POST', '/4/timesheet-approvals/logs/search', body, qs);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_periods': {
+            const { from, to } = args;
+            const data = await client.request('GET', '/4/periods', undefined, { from, to });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_user_schedule': {
+            const { accountId, from, to } = args;
+            const data = await client.request('GET', `/4/user-schedule`, undefined, { accountId, from, to });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_global_configuration': {
+            const data = await client.request('GET', '/4/globalconfiguration');
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_work_attributes': {
+            const { offset, limit } = args;
+            const data = await client.request('GET', '/4/work-attributes', undefined, { offset, limit });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_roles': {
+            const { offset, limit } = args;
+            const data = await client.request('GET', '/4/roles', undefined, { offset, limit });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/tools/teams.js

@@ -0,0 +1,176 @@
+export const toolDefinitions = [
+    {
+        name: 'tempo_get_teams',
+        description: 'Retrieve a list of Tempo teams. Can filter by name, member account ids, or specific team ids.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Filter by team name' },
+                teamIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by specific team ids' },
+                teamMembers: { type: 'array', items: { type: 'string' }, description: 'Filter by member Atlassian account ids' },
+                includeMemberships: { type: 'boolean', description: 'Include team member memberships in response' },
+                offset: { type: 'integer', description: 'Pagination offset' },
+                limit: { type: 'integer', description: 'Max results (default 50)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'tempo_get_team',
+        description: 'Retrieve a single Tempo team by id.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'integer', description: 'Team id' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'tempo_create_team',
+        description: 'Create a new Tempo team.',
+        annotations: { readOnlyHint: false },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Team name' },
+                summary: { type: 'string', description: 'Short description of the team' },
+                leadAccountId: { type: 'string', description: 'Atlassian account id of the team lead' },
+                programId: { type: 'integer', description: 'Id of the program this team belongs to' },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'tempo_update_team',
+        description: 'Update an existing Tempo team by id.',
+        annotations: { readOnlyHint: false },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'integer', description: 'Team id' },
+                name: { type: 'string', description: 'Team name' },
+                summary: { type: 'string', description: 'Short description of the team' },
+                leadAccountId: { type: 'string', description: 'Atlassian account id of the team lead' },
+                programId: { type: 'integer', description: 'Id of the program this team belongs to' },
+            },
+            required: ['id', 'name'],
+        },
+    },
+    {
+        name: 'tempo_delete_team',
+        description: 'Delete a Tempo team by id.',
+        annotations: { readOnlyHint: false },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'integer', description: 'Team id' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'tempo_get_team_memberships',
+        description: 'Retrieve team memberships, optionally filtered by account id or team id.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                accountIds: { type: 'array', items: { type: 'string' }, description: 'Filter by Atlassian account ids' },
+                teamIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by team ids' },
+                offset: { type: 'integer', description: 'Pagination offset' },
+                limit: { type: 'integer', description: 'Max results (default 50)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'tempo_search_team_memberships',
+        description: 'Search Tempo team memberships with advanced filters via POST.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                teamIds: { type: 'array', items: { type: 'integer' }, description: 'Filter by team ids' },
+                accountIds: { type: 'array', items: { type: 'string' }, description: 'Filter by Atlassian account ids' },
+                from: { type: 'string', description: 'Membership active from date (YYYY-MM-DD)' },
+                to: { type: 'string', description: 'Membership active to date (YYYY-MM-DD)' },
+                offset: { type: 'integer', description: 'Pagination offset' },
+                limit: { type: 'integer', description: 'Max results' },
+            },
+            required: [],
+        },
+    },
+];
+function buildTeamBody(args) {
+    const body = { name: args.name };
+    if (args.summary !== undefined)
+        body.summary = args.summary;
+    if (args.leadAccountId !== undefined)
+        body.leadAccountId = args.leadAccountId;
+    if (args.programId !== undefined)
+        body.programId = args.programId;
+    return body;
+}
+export async function handleTool(name, args, client) {
+    switch (name) {
+        case 'tempo_get_teams': {
+            const { name: teamName, teamIds, teamMembers, includeMemberships, offset, limit } = args;
+            const data = await client.request('GET', '/4/teams', undefined, {
+                name: teamName, teamIds, teamMembers, includeMemberships, offset, limit,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_get_team': {
+            const { id } = args;
+            const data = await client.request('GET', `/4/teams/${id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_create_team': {
+            const body = buildTeamBody(args);
+            const data = await client.request('POST', '/4/teams', body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_update_team': {
+            const { id, ...rest } = args;
+            const body = buildTeamBody(rest);
+            const data = await client.request('PUT', `/4/teams/${id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_delete_team': {
+            const { id } = args;
+            await client.request('DELETE', `/4/teams/${id}`);
+            return { content: [{ type: 'text', text: `Team ${id} deleted successfully` }] };
+        }
+        case 'tempo_get_team_memberships': {
+            const { accountIds, teamIds, offset, limit } = args;
+            const data = await client.request('GET', '/4/team-memberships', undefined, {
+                accountIds, teamIds, offset, limit,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'tempo_search_team_memberships': {
+            const { teamIds, accountIds, from, to, offset, limit } = args;
+            const query = {};
+            if (offset !== undefined)
+                query.offset = offset;
+            if (limit !== undefined)
+                query.limit = limit;
+            const body = {};
+            if (teamIds)
+                body.teamIds = teamIds;
+            if (accountIds)
+                body.accountIds = accountIds;
+            if (from)
+                body.from = from;
+            if (to)
+                body.to = to;
+            const data = await client.request('POST', '/4/team-memberships/search', body, query);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/tools/worklogs.js

@@ -0,0 +1,290 @@
+export const toolDefinitions = [
+    {
+        name: '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: [],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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: [],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+    {
+        name: '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'],
+        },
+    },
+];
+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}`);
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "tempo-api-mcp",
+  "version": "1.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>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chrischall/tempo-api-mcp"
+  },
+  "type": "module",
+  "bin": {
+    "tempo-api-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "dotenv": "^17.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "@vitest/coverage-v8": "^4.1.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  }
+}