@ama-work/mcp-atlassian 1.0.1

package/dist/client/atlassian.js

@@ -0,0 +1,28 @@
+import { createCloudClient } from "jira.js";
+import { createV1Client, createV2Client } from "confluence.js";
+import { getToken, getCloudId } from "../config.js";
+export async function createJiraClient() {
+    const [token, cloudId] = await Promise.all([getToken(), getCloudId()]);
+    return createCloudClient({
+        host: "https://api.atlassian.com",
+        auth: { type: "oauth2", accessToken: token, cloudId },
+        getAuthOn401: async () => {
+            const fresh = await getToken();
+            return { type: "oauth2", accessToken: fresh, cloudId };
+        },
+    });
+}
+export async function createConfluenceClient() {
+    const [token, cloudId] = await Promise.all([getToken(), getCloudId()]);
+    return createV2Client({
+        host: "https://api.atlassian.com",
+        auth: { type: "oauth2", accessToken: token, cloudId },
+    });
+}
+export async function createConfluenceV1Client() {
+    const [token, cloudId] = await Promise.all([getToken(), getCloudId()]);
+    return createV1Client({
+        host: "https://api.atlassian.com",
+        auth: { type: "oauth2", accessToken: token, cloudId },
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export declare function getToken(): Promise<string>;
+export declare function getCloudId(): Promise<string>;

package/dist/config.js

@@ -0,0 +1,59 @@
+const REFRESH_BUFFER_MS = 5 * 60 * 1000;
+let cache = null;
+function env(name) {
+    return process.env[name];
+}
+async function fetchFromRegistry() {
+    const registryUrl = env("REGISTRY_URL");
+    const instanceId = env("INSTANCE_ID");
+    const gatewayPsk = env("GATEWAY_PSK");
+    if (!registryUrl || !instanceId || !gatewayPsk) {
+        throw new Error("Registry mode requires REGISTRY_URL, INSTANCE_ID, and GATEWAY_PSK");
+    }
+    const url = `${registryUrl}/instances/${instanceId}/secrets`;
+    const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${gatewayPsk}` },
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Registry fetch failed (${res.status}): ${body}`);
+    }
+    const data = (await res.json());
+    return {
+        token: data.oauth.access_token,
+        cloudId: data.oauth.cloud_id,
+        expiresAt: data.oauth.expires_at,
+    };
+}
+function resolveStandalone() {
+    const token = env("ATLASSIAN_ACCESS_TOKEN");
+    const cloudId = env("ATLASSIAN_CLOUD_ID");
+    if (!token || !cloudId)
+        return null;
+    return {
+        token,
+        cloudId,
+        expiresAt: Number.MAX_SAFE_INTEGER,
+    };
+}
+function isExpired(c) {
+    return Date.now() >= c.expiresAt - REFRESH_BUFFER_MS;
+}
+async function load() {
+    const standalone = resolveStandalone();
+    if (standalone)
+        return standalone;
+    return fetchFromRegistry();
+}
+export async function getToken() {
+    if (!cache || isExpired(cache)) {
+        cache = await load();
+    }
+    return cache.token;
+}
+export async function getCloudId() {
+    if (!cache || isExpired(cache)) {
+        cache = await load();
+    }
+    return cache.cloudId;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,11 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerJiraTools } from "./tools/jira.js";
+import { registerConfluenceTools } from "./tools/confluence.js";
+import { registerMetaTools } from "./tools/meta.js";
+const server = new McpServer({ name: "ama-mcp-atlassian", version: "0.1.0" });
+registerJiraTools(server);
+registerConfluenceTools(server);
+registerMetaTools(server);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/confluence-comment.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConfluenceCommentTools(server: McpServer): void;

package/dist/tools/confluence-comment.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { createConfluenceClient } from "../client/atlassian.js";
+import { toADF } from "../client/adf.js";
+export function registerConfluenceCommentTools(server) {
+    server.tool("confluence_add_comment", "Add a footer comment to a Confluence page.", {
+        pageId: z.string().describe("Numeric page ID"),
+        body: z.string().describe("Comment text as plain markdown. Converted to ADF before sending."),
+    }, async ({ pageId, body }) => {
+        const client = await createConfluenceClient();
+        const adfDoc = toADF(body);
+        const comment = await client.comment.createFooterComment({
+            pageId,
+            body: { representation: "atlas_doc_format", value: adfDoc },
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(comment, null, 2) }],
+        };
+    });
+}

package/dist/tools/confluence-create.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConfluenceCreateTools(server: McpServer): void;

package/dist/tools/confluence-create.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { createConfluenceClient } from "../client/atlassian.js";
+import { toADF } from "../client/adf.js";
+export function registerConfluenceCreateTools(server) {
+    server.tool("confluence_create_page", "Create a new Confluence page in the specified space.", {
+        spaceId: z.string().describe("Numeric space ID. Use confluence_get_spaces to look up IDs by name or key."),
+        title: z.string().describe("Page title"),
+        body: z.string().describe("Page content as plain markdown. Converted to ADF before sending."),
+        parentId: z.string().optional().describe("Numeric ID of parent page. If omitted, page is created at space root."),
+        status: z.enum(["current", "draft"]).optional().describe('"current" (published, default) or "draft"'),
+    }, async ({ spaceId, title, body, parentId, status }) => {
+        const client = await createConfluenceClient();
+        const adfDoc = toADF(body);
+        const params = {
+            spaceId,
+            title,
+            body: { representation: "atlas_doc_format", value: adfDoc },
+            ...(parentId ? { parentId } : {}),
+            status: status ?? "current",
+        };
+        const page = await client.page.createPage(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(page, null, 2) }],
+        };
+    });
+}

package/dist/tools/confluence-get.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConfluenceGetTools(server: McpServer): void;

package/dist/tools/confluence-get.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { createConfluenceClient } from "../client/atlassian.js";
+import { fromADF } from "../client/adf.js";
+export function registerConfluenceGetTools(server) {
+    server.tool("confluence_get_page", "Get the full content of a Confluence page by its numeric page ID. Returns title, spaceKey, body as markdown, version number, and last-modified date.", {
+        pageId: z.string().describe('Numeric page ID (e.g. "98383"). Find IDs via confluence_search.'),
+    }, async ({ pageId }) => {
+        const client = await createConfluenceClient();
+        const page = await client.page.getPageById({
+            id: Number(pageId),
+            bodyFormat: "atlas_doc_format",
+            includeVersion: true,
+        });
+        const body = page.body;
+        const adfBody = body?.atlas_doc_format;
+        const markdown = adfBody?.value ? fromADF(JSON.parse(adfBody.value)) : "";
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        pageId: page.id,
+                        title: page.title,
+                        spaceId: page.spaceId,
+                        parentId: page.parentId,
+                        status: page.status,
+                        body: markdown,
+                        version: page.version?.number,
+                        lastModified: page.version?.createdAt,
+                    }, null, 2),
+                }],
+        };
+    });
+}

package/dist/tools/confluence-search.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConfluenceSearchTools(server: McpServer): void;

package/dist/tools/confluence-search.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { createConfluenceV1Client } from "../client/atlassian.js";
+export function registerConfluenceSearchTools(server) {
+    server.tool("confluence_search", "Search Confluence content using CQL (Confluence Query Language). Returns matching pages, blog posts, and spaces with title, spaceKey, URL, and a short excerpt.", {
+        cql: z.string().describe('CQL query string. Examples: space = "ENG" AND type = page AND text ~ "deploy", title = "Architecture Overview"'),
+        limit: z.number().int().min(1).max(50).default(10).describe("Max results (1-50, default 10)"),
+    }, async ({ cql, limit }) => {
+        const client = await createConfluenceV1Client();
+        const result = await client.search.searchByCQL({ cql, limit });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/confluence-spaces.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConfluenceSpaceTools(server: McpServer): void;

package/dist/tools/confluence-spaces.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { createConfluenceClient } from "../client/atlassian.js";
+export function registerConfluenceSpaceTools(server) {
+    server.tool("confluence_get_spaces", "List Confluence spaces accessible to the authenticated user. Returns space ID, key, name, type, and homepage ID.", {
+        limit: z.number().int().min(1).max(50).default(25).describe("Max results (1-50, default 25)"),
+        type: z.enum(["global", "personal"]).optional().describe('Filter by type: "global" or "personal"'),
+    }, async ({ limit, type }) => {
+        const client = await createConfluenceClient();
+        const result = await client.space.getSpaces({
+            limit,
+            type: type ?? undefined,
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/confluence-update.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConfluenceUpdateTools(server: McpServer): void;

package/dist/tools/confluence-update.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { createConfluenceClient } from "../client/atlassian.js";
+import { toADF } from "../client/adf.js";
+export function registerConfluenceUpdateTools(server) {
+    server.tool("confluence_update_page", "Update the title and/or content of an existing Confluence page. Requires the current version number — Confluence rejects updates that omit it.", {
+        pageId: z.string().describe("Numeric page ID"),
+        title: z.string().describe("New title (required even if unchanged)"),
+        body: z.string().describe("New content as plain markdown. Converted to ADF before sending."),
+        versionNumber: z.number().int().describe("Current version number. Fetch with confluence_get_page first. Must increment by 1."),
+    }, async ({ pageId, title, body, versionNumber }) => {
+        const client = await createConfluenceClient();
+        const adfDoc = toADF(body);
+        const params = {
+            id: Number(pageId),
+            title,
+            body: { representation: "atlas_doc_format", value: adfDoc },
+            version: { number: versionNumber + 1 },
+            status: "current",
+        };
+        const page = await client.page.updatePage(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(page, null, 2) }],
+        };
+    });
+}

package/dist/tools/confluence.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConfluenceTools(server: McpServer): void;

package/dist/tools/confluence.js

@@ -0,0 +1,14 @@
+import { registerConfluenceSearchTools } from "./confluence-search.js";
+import { registerConfluenceGetTools } from "./confluence-get.js";
+import { registerConfluenceCreateTools } from "./confluence-create.js";
+import { registerConfluenceUpdateTools } from "./confluence-update.js";
+import { registerConfluenceCommentTools } from "./confluence-comment.js";
+import { registerConfluenceSpaceTools } from "./confluence-spaces.js";
+export function registerConfluenceTools(server) {
+    registerConfluenceSearchTools(server);
+    registerConfluenceGetTools(server);
+    registerConfluenceCreateTools(server);
+    registerConfluenceUpdateTools(server);
+    registerConfluenceCommentTools(server);
+    registerConfluenceSpaceTools(server);
+}

package/dist/tools/jira-comment.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerJiraCommentTools(server: McpServer): void;

package/dist/tools/jira-comment.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { createJiraClient } from "../client/atlassian.js";
+import { toADF } from "../client/adf.js";
+export function registerJiraCommentTools(server) {
+    server.tool("jira_add_comment", "Add a comment to a Jira issue.", {
+        issueKey: z.string().describe("Issue key"),
+        body: z
+            .string()
+            .describe("Comment text (plain text, auto-converted to ADF)"),
+    }, async ({ issueKey, body }) => {
+        const client = await createJiraClient();
+        const comment = await client.issueComments.addComment({
+            issueIdOrKey: issueKey,
+            body: toADF(body),
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(comment, null, 2) }],
+        };
+    });
+}

package/dist/tools/jira-create.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerJiraCreateTools(server: McpServer): void;

package/dist/tools/jira-create.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { createJiraClient } from "../client/atlassian.js";
+import { toADF } from "../client/adf.js";
+function buildCreateFields(input) {
+    const fields = {
+        project: { key: input.projectKey },
+        summary: input.summary,
+        issuetype: { name: input.issueType },
+    };
+    if (input.description)
+        fields.description = toADF(input.description);
+    if (input.assigneeAccountId)
+        fields.assignee = { id: input.assigneeAccountId };
+    if (input.priority)
+        fields.priority = { name: input.priority };
+    if (input.labels)
+        fields.labels = input.labels;
+    if (input.parentKey)
+        fields.parent = { key: input.parentKey };
+    return fields;
+}
+export function registerJiraCreateTools(server) {
+    server.tool("jira_create_issue", "Create a new Jira issue in the specified project.", {
+        projectKey: z.string().describe("Project key (e.g. PROJ)"),
+        summary: z.string().describe("Issue title/summary"),
+        issueType: z.string().describe("Issue type name, e.g. Task, Bug, Story"),
+        description: z.string().optional().describe("Issue body text (plain text, auto-converted to ADF)"),
+        assigneeAccountId: z.string().optional().describe("Atlassian account ID of assignee"),
+        priority: z.string().optional().describe("Priority name: Highest, High, Medium, Low, Lowest"),
+        labels: z.array(z.string()).optional().describe("Array of label strings"),
+        parentKey: z.string().optional().describe("Parent issue key (for subtasks)"),
+    }, async (input) => {
+        const client = await createJiraClient();
+        const created = await client.issues.createIssue({ fields: buildCreateFields(input) });
+        return {
+            content: [{ type: "text", text: JSON.stringify(created, null, 2) }],
+        };
+    });
+}

package/dist/tools/jira-get.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerJiraGetTools(server: McpServer): void;

package/dist/tools/jira-get.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { createJiraClient } from "../client/atlassian.js";
+export function registerJiraGetTools(server) {
+    server.tool("jira_get_issue", "Get full details of a single Jira issue by its key (e.g. PROJ-123). Returns fields including summary, description, status, assignee, comments, and subtasks.", {
+        issueKey: z.string().describe("Issue key (e.g. PROJ-42)"),
+        fields: z
+            .array(z.string())
+            .optional()
+            .describe("Fields to return. Omit for all fields."),
+    }, async ({ issueKey, fields }) => {
+        const client = await createJiraClient();
+        const issue = await client.issues.getIssue({
+            issueIdOrKey: issueKey,
+            fields,
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
+        };
+    });
+}

package/dist/tools/jira-projects.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerJiraProjectTools(server: McpServer): void;

package/dist/tools/jira-projects.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { createJiraClient } from "../client/atlassian.js";
+export function registerJiraProjectTools(server) {
+    server.tool("jira_get_projects", "List all Jira projects accessible to the authenticated user. Returns project key, name, type, and lead.", {
+        maxResults: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .default(50)
+            .describe("Max projects to return (default 50)"),
+        query: z.string().optional().describe("Optional name filter string"),
+    }, async ({ maxResults, query }) => {
+        const client = await createJiraClient();
+        const result = await client.projects.searchProjects({
+            maxResults,
+            query,
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/jira-search.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerJiraSearchTools(server: McpServer): void;

package/dist/tools/jira-search.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { createJiraClient } from "../client/atlassian.js";
+const DEFAULT_FIELDS = [
+    "summary",
+    "status",
+    "assignee",
+    "priority",
+    "issuetype",
+    "created",
+    "updated",
+];
+export function registerJiraSearchTools(server) {
+    server.tool("jira_search_issues", "Search Jira issues using JQL. Returns a list of matching issues with key, summary, status, assignee, and priority.", {
+        jql: z.string().describe("JQL query string"),
+        maxResults: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .default(20)
+            .describe("Max issues to return (1-100, default 20)"),
+        fields: z
+            .array(z.string())
+            .optional()
+            .describe("Fields to include in results"),
+    }, async ({ jql, maxResults, fields }) => {
+        const client = await createJiraClient();
+        const result = await client.issueSearch.searchAndReconsileIssuesUsingJql({
+            jql,
+            maxResults,
+            fields: fields ?? DEFAULT_FIELDS,
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/jira-transition.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerJiraTransitionTools(server: McpServer): void;

package/dist/tools/jira-transition.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { createJiraClient } from "../client/atlassian.js";
+function textResponse(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+async function handleTransition(issueKey, transitionName) {
+    const client = await createJiraClient();
+    const { transitions } = await client.issues.getTransitions({ issueIdOrKey: issueKey });
+    if (!transitions || transitions.length === 0) {
+        return textResponse({ error: "No transitions available for this issue" });
+    }
+    const match = transitions.find((t) => t.name?.toLowerCase() === transitionName.toLowerCase());
+    if (!match) {
+        return textResponse({
+            error: `No transition named "${transitionName}" found`,
+            available: transitions.map((t) => t.name),
+        });
+    }
+    await client.issues.doTransition({
+        issueIdOrKey: issueKey,
+        transition: { id: match.id },
+    });
+    return textResponse({ success: true, transitionedTo: transitionName });
+}
+export function registerJiraTransitionTools(server) {
+    server.tool("jira_transition_issue", "Move a Jira issue to a new status by triggering a workflow transition (e.g. In Progress, Done).", {
+        issueKey: z.string().describe("Issue key"),
+        transitionName: z.string().describe('Target status name, e.g. "In Progress", "Done", "Closed"'),
+    }, ({ issueKey, transitionName }) => handleTransition(issueKey, transitionName));
+}

package/dist/tools/jira-update.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerJiraUpdateTools(server: McpServer): void;

package/dist/tools/jira-update.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { createJiraClient } from "../client/atlassian.js";
+import { toADF } from "../client/adf.js";
+export function registerJiraUpdateTools(server) {
+    server.tool("jira_update_issue", "Update fields on an existing Jira issue.", {
+        issueKey: z.string().describe("Issue key (e.g. PROJ-42)"),
+        summary: z.string().optional().describe("New summary"),
+        description: z
+            .string()
+            .optional()
+            .describe("New description (plain text, auto-converted to ADF)"),
+        assigneeAccountId: z
+            .string()
+            .optional()
+            .describe("New assignee's account ID"),
+        priority: z.string().optional().describe("New priority name"),
+        labels: z
+            .array(z.string())
+            .optional()
+            .describe("Replace labels with this array"),
+    }, async ({ issueKey, summary, description, assigneeAccountId, priority, labels }) => {
+        const client = await createJiraClient();
+        const fields = {};
+        if (summary)
+            fields.summary = summary;
+        if (description)
+            fields.description = toADF(description);
+        if (assigneeAccountId)
+            fields.assignee = { id: assigneeAccountId };
+        if (priority)
+            fields.priority = { name: priority };
+        if (labels)
+            fields.labels = labels;
+        await client.issues.editIssue({ issueIdOrKey: issueKey, fields });
+        return {
+            content: [{ type: "text", text: `Updated ${issueKey}` }],
+        };
+    });
+}

package/dist/tools/jira.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerJiraTools(server: McpServer): void;

package/dist/tools/jira.js

@@ -0,0 +1,16 @@
+import { registerJiraSearchTools } from "./jira-search.js";
+import { registerJiraGetTools } from "./jira-get.js";
+import { registerJiraCreateTools } from "./jira-create.js";
+import { registerJiraUpdateTools } from "./jira-update.js";
+import { registerJiraTransitionTools } from "./jira-transition.js";
+import { registerJiraCommentTools } from "./jira-comment.js";
+import { registerJiraProjectTools } from "./jira-projects.js";
+export function registerJiraTools(server) {
+    registerJiraSearchTools(server);
+    registerJiraGetTools(server);
+    registerJiraCreateTools(server);
+    registerJiraUpdateTools(server);
+    registerJiraTransitionTools(server);
+    registerJiraCommentTools(server);
+    registerJiraProjectTools(server);
+}

package/dist/tools/meta.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerMetaTools(server: McpServer): void;

package/dist/tools/meta.js

@@ -0,0 +1,18 @@
+import { getToken } from "../config.js";
+export function registerMetaTools(server) {
+    server.tool("atlassian_whoami", "Returns the identity of the currently authenticated Atlassian user — account ID, display name, email, and accessible site URLs.", {}, async () => {
+        const token = await getToken();
+        const res = await fetch("https://api.atlassian.com/me", {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: true, status: res.status, message: `Failed to fetch user info: ${res.statusText}` }) }],
+            };
+        }
+        const data = await res.json();
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+export interface Secrets {
+    oauth: {
+        access_token: string;
+        refresh_token: string;
+        expires_at: number;
+        scope: string;
+        cloud_id: string;
+    };
+}
+export interface TokenCache {
+    token: string;
+    cloudId: string;
+    expiresAt: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};