@authn8/mcp-server 1.0.5 → 1.1.0

package/README.md

@@ -92,19 +92,24 @@ Add to your Cursor MCP settings:
 
 ## Available Tools
 
+All tools declare an output schema and return `structuredContent` alongside the
+text block, so clients get typed results without re-parsing JSON out of text.
+
 ### list_accounts
 
 Returns all 2FA accounts accessible to this token.
 
 **Example response:**
 ```json
-[
-  {
-    "id": "924c52a6-4457-4970-a39f-4dc620217683",
-    "name": "AWS Production",
-    "issuer": "amazon.com"
-  }
-]
+{
+  "accounts": [
+    {
+      "id": "924c52a6-4457-4970-a39f-4dc620217683",
+      "name": "AWS Production",
+      "issuerDomain": "amazon.com"
+    }
+  ]
+}
 ```
 
 ### get_otp
@@ -113,15 +118,33 @@ Generates a TOTP code for a specific account.
 
 **Parameters:**
 - `account_id` (string, optional) - UUID of the account
-- `account_name` (string, optional) - Name to search for (partial match)
+- `account_name` (string, optional) - Name or issuer domain to search for (case-insensitive partial match)
 
-Provide either `account_id` or `account_name`. If multiple accounts match the name, the tool returns a list of matches.
+Provide either `account_id` or `account_name`. If multiple accounts match the
+name, the tool returns them in `multipleMatches` so you can retry with an
+`account_id`.
 
 **Example response:**
 ```json
 {
-  "account": "AWS Production",
-  "code": "483920"
+  "name": "AWS Production",
+  "code": "483920",
+  "length": 6
+}
+```
+
+**Ambiguous match:**
+```json
+{
+  "error": "Multiple accounts match 'aws'. Please be more specific or use account_id.",
+  "length": 0,
+  "multipleMatches": [
+    {
+      "id": "924c52a6-4457-4970-a39f-4dc620217683",
+      "name": "AWS Production",
+      "issuerDomain": "amazon.com"
+    }
+  ]
 }
 ```
 
@@ -132,11 +155,13 @@ Returns information about the current token.
 **Example response:**
 ```json
 {
-  "business": "Bytecode Solutions",
-  "token_name": "MCP Server 2",
-  "scoped_groups": ["HR"],
-  "account_count": 1,
-  "expires_at": "2025-12-25T23:59:59Z"
+  "tokenName": "MCP Server 2",
+  "businessName": "Bytecode Solutions",
+  "scopedGroups": [
+    { "id": "cfeba14a-e990-49e8-b6e5-61d63f7d68c8", "name": "HR" }
+  ],
+  "expiresAt": "2025-12-25T23:59:59Z",
+  "accountCount": 1
 }
 ```
 

package/dist/index.js

@@ -5,9 +5,13 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/client.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
 var API_URL = process.env.AUTHN8_API_URL || "https://api.authn8.com";
 var API_KEY = process.env.AUTHN8_API_KEY;
-var USER_AGENT = "authn8-mcp/1.0.0";
+var USER_AGENT = `authn8-mcp/${version}`;
+var PACKAGE_VERSION = version;
 var Authn8Error = class extends Error {
   constructor(message, statusCode) {
     super(message);
@@ -65,8 +69,8 @@ async function apiRequest(endpoint, method = "GET") {
 async function getTokenInfo() {
   return apiRequest("/api/pat/me");
 }
-async function listAccounts() {
-  if (accountsCache && Date.now() - accountsCache.timestamp < CACHE_TTL_MS) {
+async function listAccounts(forceRefresh = false) {
+  if (!forceRefresh && accountsCache && Date.now() - accountsCache.timestamp < CACHE_TTL_MS) {
     return accountsCache.accounts;
   }
   const response = await apiRequest("/api/pat/accounts");
@@ -76,25 +80,25 @@ async function listAccounts() {
   };
   return response.accounts;
 }
+function servedFromCache() {
+  return accountsCache !== null && Date.now() - accountsCache.timestamp < CACHE_TTL_MS;
+}
 async function getOtp(accountId) {
   return apiRequest(`/api/pat/otp/${accountId}`);
 }
-async function findAccountByName(name) {
-  const accounts = await listAccounts();
+function matchAccounts(accounts, name) {
   const lowerName = name.toLowerCase();
-  const matches = accounts.filter(
+  return accounts.filter(
     (acc) => acc.name?.toLowerCase().includes(lowerName) || acc.issuerDomain?.toLowerCase().includes(lowerName)
   );
-  if (matches.length === 0) {
-    throw new Authn8Error(
-      `No account found matching "${name}". Available accounts:
-${accounts.map((a) => `  - ${a.name} (${a.issuerDomain || "unknown"})`).join("\n")}`
-    );
-  }
-  if (matches.length === 1) {
-    return { account: matches[0] };
+}
+async function findAccountByName(name) {
+  const accounts = await listAccounts();
+  const matches = matchAccounts(accounts, name);
+  if (matches.length > 0 || !servedFromCache()) {
+    return matches;
   }
-  return { matches };
+  return matchAccounts(await listAccounts(true), name);
 }
 async function validateToken() {
   try {
@@ -111,131 +115,121 @@ async function validateToken() {
 
 // src/tools.ts
 import { z } from "zod";
+var accountShape = z.object({
+  id: z.uuid(),
+  name: z.string(),
+  issuerDomain: z.string().nullable()
+});
+var listAccountsOutput = z.object({
+  error: z.string().optional(),
+  accounts: z.array(accountShape).optional()
+});
+var getOtpOutput = z.object({
+  error: z.string().optional(),
+  name: z.string().optional(),
+  code: z.string().optional(),
+  length: z.number().int(),
+  multipleMatches: z.array(accountShape).optional()
+});
+var whoamiOutput = z.object({
+  error: z.string().optional(),
+  tokenName: z.string().optional(),
+  businessName: z.string().optional(),
+  scopedGroups: z.array(z.object({ id: z.uuid(), name: z.string() })).optional(),
+  expiresAt: z.string().optional(),
+  accountCount: z.number().int()
+});
 var toolDefinitions = {
   list_accounts: {
-    description: "Returns all 2FA accounts accessible to this token. Use this to see what accounts are available before requesting an OTP code.",
-    inputSchema: z.object({})
+    description: "Returns all 2FA accounts accessible to this token. Use this to see what accounts are available before requesting an OTP code. Each account includes: id (UUID for get_otp), name, and issuerDomain. Returns an empty list if no accounts are accessible.",
+    inputSchema: z.object({}),
+    outputSchema: listAccountsOutput
   },
   get_otp: {
-    description: "Generates a TOTP code for a specific account. You can provide either the account_id (UUID) or account_name (partial match supported). If multiple accounts match the name, you'll get a list of matches to be more specific.",
+    description: "Generates a TOTP code for a specific account. REQUIRED: Provide either account_id OR account_name (at least one must be specified). Errors: Returns 'No account found' if the name doesn't match any account. Returns 'Multiple accounts match' with a list of matches in the 'multipleMatches' field if the name is ambiguous - use the returned account_id to retry.",
     inputSchema: z.object({
-      account_id: z.uuid().optional().describe("UUID of the account"),
-      account_name: z.string().optional().describe("Name to search for (partial match)")
-    })
+      account_id: z.uuid().optional().describe(
+        "UUID of the account. Use this for exact matching, especially after resolving ambiguous name matches."
+      ),
+      account_name: z.string().optional().describe(
+        "Name or issuer domain to search for (case-insensitive partial match). If multiple accounts match, returns a list to choose from."
+      )
+    }),
+    outputSchema: getOtpOutput
   },
   whoami: {
     description: "Returns information about the current token and what it has access to, including the business name, token name, scoped groups, account count, and expiration date.",
-    inputSchema: z.object({})
+    inputSchema: z.object({}),
+    outputSchema: whoamiOutput
   }
 };
-async function handleListAccounts() {
-  const accounts = await listAccounts();
-  if (accounts.length === 0) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: "No accounts are accessible with this token."
-        }
-      ]
-    };
-  }
-  const formatted = accounts.map((acc) => ({
-    id: acc.id,
-    name: acc.name,
-    issuer: acc.issuerDomain || null
-  }));
+function result(payload) {
   return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(formatted, null, 2)
-      }
-    ]
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    structuredContent: payload
   };
 }
+async function handleListAccounts() {
+  const accounts = await listAccounts();
+  return result({
+    accounts: accounts.map((acc) => ({
+      id: acc.id,
+      name: acc.name,
+      issuerDomain: acc.issuerDomain ?? null
+    }))
+  });
+}
 async function handleGetOtp(args) {
   const { account_id, account_name } = args;
   if (!account_id && !account_name) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: "Error: Either account_id or account_name must be provided."
-        }
-      ]
-    };
+    return result({
+      error: "Either account_id or account_name must be provided",
+      length: 0
+    });
   }
   let targetAccountId;
-  let accountName;
   if (account_id) {
     targetAccountId = account_id;
-    const accounts = await listAccounts();
-    const account = accounts.find((a) => a.id === account_id);
-    if (!account) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: Account with ID "${account_id}" not found. Use list_accounts to see available accounts.`
-          }
-        ]
-      };
-    }
-    accountName = account.name;
   } else {
-    const result = await findAccountByName(account_name);
-    if ("matches" in result) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Multiple accounts match "${account_name}". Please be more specific:
-${result.matches.map((a) => `  - ${a.name} (${a.issuerDomain || "unknown"}) - ID: ${a.id}`).join("\n")}`
-          }
-        ]
-      };
+    const matches = await findAccountByName(account_name);
+    if (matches.length === 0) {
+      return result({
+        error: `No account found matching '${account_name}'. Use list_accounts to see available accounts.`,
+        length: 0
+      });
+    }
+    if (matches.length > 1) {
+      return result({
+        error: `Multiple accounts match '${account_name}'. Please be more specific or use account_id.`,
+        length: 0,
+        multipleMatches: matches.map((a) => ({
+          id: a.id,
+          name: a.name,
+          issuerDomain: a.issuerDomain ?? null
+        }))
+      });
     }
-    targetAccountId = result.account.id;
-    accountName = result.account.name;
+    targetAccountId = matches[0].id;
   }
   const otp = await getOtp(targetAccountId);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            account: accountName,
-            code: otp.code
-          },
-          null,
-          2
-        )
-      }
-    ]
-  };
+  return result({
+    name: otp.name,
+    code: otp.code,
+    length: otp.length
+  });
 }
 async function handleWhoami() {
   const info = await getTokenInfo();
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            business: info.businessName,
-            token_name: info.tokenName,
-            scoped_groups: info.scopedGroups.map((g) => g.name),
-            account_count: info.accountCount,
-            expires_at: info.expiresAt
-          },
-          null,
-          2
-        )
-      }
-    ]
-  };
+  return result({
+    tokenName: info.tokenName,
+    businessName: info.businessName,
+    scopedGroups: (info.scopedGroups ?? []).map((g) => ({
+      id: g.id,
+      name: g.name
+    })),
+    expiresAt: info.expiresAt,
+    accountCount: info.accountCount
+  });
 }
 
 // src/index.ts
@@ -248,13 +242,24 @@ function formatDate(isoDate) {
   });
 }
 function displayStartupInfo(info) {
-  console.error("Authn8 MCP Server");
+  console.error(`Authn8 MCP Server v${PACKAGE_VERSION}`);
   console.error(`Business: ${info.businessName}`);
   console.error(`Token: ${info.tokenName}`);
   console.error(`Accounts: ${info.accountCount}`);
   console.error(`Expires: ${formatDate(info.expiresAt)}`);
   console.error("");
 }
+function toErrorResult(error) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+      }
+    ],
+    isError: true
+  };
+}
 async function main() {
   let tokenInfo;
   try {
@@ -269,26 +274,20 @@ async function main() {
   displayStartupInfo(tokenInfo);
   const server = new McpServer({
     name: "authn8-mcp",
-    version: "1.0.0"
+    version: PACKAGE_VERSION
   });
   server.registerTool(
     "list_accounts",
     {
       description: toolDefinitions.list_accounts.description,
-      inputSchema: toolDefinitions.list_accounts.inputSchema
+      inputSchema: toolDefinitions.list_accounts.inputSchema,
+      outputSchema: toolDefinitions.list_accounts.outputSchema
     },
     async () => {
       try {
         return await handleListAccounts();
       } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ]
-        };
+        return toErrorResult(error);
       }
     }
   );
@@ -296,20 +295,16 @@ async function main() {
     "get_otp",
     {
       description: toolDefinitions.get_otp.description,
-      inputSchema: toolDefinitions.get_otp.inputSchema
+      inputSchema: toolDefinitions.get_otp.inputSchema,
+      outputSchema: toolDefinitions.get_otp.outputSchema
     },
     async (args) => {
       try {
-        return await handleGetOtp(args);
+        return await handleGetOtp(
+          args
+        );
       } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ]
-        };
+        return toErrorResult(error);
       }
     }
   );
@@ -317,20 +312,14 @@ async function main() {
     "whoami",
     {
       description: toolDefinitions.whoami.description,
-      inputSchema: toolDefinitions.whoami.inputSchema
+      inputSchema: toolDefinitions.whoami.inputSchema,
+      outputSchema: toolDefinitions.whoami.outputSchema
     },
     async () => {
       try {
         return await handleWhoami();
       } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ]
-        };
+        return toErrorResult(error);
       }
     }
   );

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "@authn8/mcp-server",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "MCP server for Authn8 2FA code access",
   "type": "module",
   "bin": {
     "authn8-mcp": "./dist/index.js"
   },
   "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts",
-    "dev": "node --loader ts-node/esm src/index.ts",
+    "dev": "tsup src/index.ts --format esm --watch",
     "start": "node dist/index.js"
   },
   "keywords": [
@@ -21,13 +24,13 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/authn8/mcp-server"
+    "url": "git+https://github.com/authn8/mcp-server.git"
   },
   "homepage": "https://authn8.com",
-  "author": "",
-  "license": "ISC",
+  "author": "Authn8",
+  "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.24.3",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "zod": "^4.1.13"
   },
   "devDependencies": {

package/Dockerfile

@@ -1,6 +0,0 @@
-FROM node:22-alpine
-WORKDIR /app
-COPY package*.json ./
-RUN npm ci --only=production
-COPY dist/ ./dist/
-ENTRYPOINT ["node", "dist/index.js"]

package/src/client.ts

@@ -1,156 +0,0 @@
-const API_URL = process.env.AUTHN8_API_URL || "https://api.authn8.com";
-const API_KEY = process.env.AUTHN8_API_KEY;
-const USER_AGENT = "authn8-mcp/1.0.0";
-
-export interface TokenInfo {
-  businessName: string;
-  tokenName: string;
-  scopedGroups: Array<{ id: string; name: string }>;
-  accountCount: number;
-  expiresAt: string;
-}
-
-export interface Account {
-  id: string;
-  name: string;
-  issuerDomain: string | null;
-}
-
-interface AccountsResponse {
-  accounts: Account[];
-}
-
-export interface OtpResponse {
-  name: string;
-  code: string;
-  length: number;
-}
-
-class Authn8Error extends Error {
-  constructor(
-    message: string,
-    public statusCode?: number
-  ) {
-    super(message);
-    this.name = "Authn8Error";
-  }
-}
-
-let accountsCache: { accounts: Account[]; timestamp: number } | null = null;
-const CACHE_TTL_MS = 60 * 1000; // 60 seconds
-
-async function apiRequest<T>(
-  endpoint: string,
-  method: string = "GET"
-): Promise<T> {
-  if (!API_KEY) {
-    throw new Authn8Error(
-      "AUTHN8_API_KEY environment variable is not set. Please set it to your PAT token from the Authn8 dashboard."
-    );
-  }
-
-  const url = `${API_URL}${endpoint}`;
-
-  const response = await fetch(url, {
-    method,
-    headers: {
-      Authorization: `Bearer ${API_KEY}`,
-      "User-Agent": USER_AGENT,
-      "Content-Type": "application/json",
-    },
-  });
-
-  if (!response.ok) {
-    if (response.status === 401) {
-      throw new Authn8Error(
-        "Token is invalid or expired. Please check your token in the Authn8 dashboard.",
-        401
-      );
-    }
-    if (response.status === 403) {
-      throw new Authn8Error(
-        "Token does not have permission to access this resource.",
-        403
-      );
-    }
-    if (response.status === 404) {
-      throw new Authn8Error("Resource not found.", 404);
-    }
-    if (response.status === 429) {
-      const retryAfter = response.headers.get("Retry-After");
-      throw new Authn8Error(
-        `Rate limited. ${retryAfter ? `Retry after ${retryAfter} seconds.` : "Please try again later."}`,
-        429
-      );
-    }
-    throw new Authn8Error(
-      `API request failed with status ${response.status}`,
-      response.status
-    );
-  }
-
-  return response.json() as Promise<T>;
-}
-
-export async function getTokenInfo(): Promise<TokenInfo> {
-  return apiRequest<TokenInfo>("/api/pat/me");
-}
-
-export async function listAccounts(): Promise<Account[]> {
-  // Check cache
-  if (accountsCache && Date.now() - accountsCache.timestamp < CACHE_TTL_MS) {
-    return accountsCache.accounts;
-  }
-
-  const response = await apiRequest<AccountsResponse>("/api/pat/accounts");
-
-  // Update cache
-  accountsCache = {
-    accounts: response.accounts,
-    timestamp: Date.now(),
-  };
-
-  return response.accounts;
-}
-
-export async function getOtp(accountId: string): Promise<OtpResponse> {
-  return apiRequest<OtpResponse>(`/api/pat/otp/${accountId}`);
-}
-
-export async function findAccountByName(
-  name: string
-): Promise<{ account: Account } | { matches: Account[] }> {
-  const accounts = await listAccounts();
-  const lowerName = name.toLowerCase();
-
-  const matches = accounts.filter(
-    (acc) =>
-      acc.name?.toLowerCase().includes(lowerName) ||
-      acc.issuerDomain?.toLowerCase().includes(lowerName)
-  );
-
-  if (matches.length === 0) {
-    throw new Authn8Error(
-      `No account found matching "${name}". Available accounts:\n${accounts.map((a) => `  - ${a.name} (${a.issuerDomain || "unknown"})`).join("\n")}`
-    );
-  }
-
-  if (matches.length === 1) {
-    return { account: matches[0] };
-  }
-
-  return { matches };
-}
-
-export async function validateToken(): Promise<TokenInfo> {
-  try {
-    return await getTokenInfo();
-  } catch (error) {
-    if (error instanceof Authn8Error) {
-      throw error;
-    }
-    throw new Authn8Error(
-      `Failed to connect to Authn8 API. Please check AUTHN8_API_URL (${API_URL}). Error: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}

package/src/index.ts

@@ -1,125 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { validateToken, type TokenInfo } from "./client.js";
-import {
-  toolDefinitions,
-  handleListAccounts,
-  handleGetOtp,
-  handleWhoami,
-} from "./tools.js";
-
-function formatDate(isoDate: string): string {
-  const date = new Date(isoDate);
-  return date.toLocaleDateString("en-US", {
-    month: "short",
-    day: "numeric",
-    year: "numeric",
-  });
-}
-
-function displayStartupInfo(info: TokenInfo): void {
-  console.error("Authn8 MCP Server");
-  console.error(`Business: ${info.businessName}`);
-  console.error(`Token: ${info.tokenName}`);
-  console.error(`Accounts: ${info.accountCount}`);
-  console.error(`Expires: ${formatDate(info.expiresAt)}`);
-  console.error("");
-}
-
-async function main(): Promise<void> {
-  // Validate token on startup
-  let tokenInfo: TokenInfo;
-  try {
-    tokenInfo = await validateToken();
-  } catch (error) {
-    console.error(
-      "Error:",
-      error instanceof Error ? error.message : String(error)
-    );
-    process.exit(1);
-  }
-
-  displayStartupInfo(tokenInfo);
-
-  // Create MCP server
-  const server = new McpServer({
-    name: "authn8-mcp",
-    version: "1.0.0",
-  });
-
-  // Register tools
-  server.registerTool(
-    "list_accounts",
-    {
-      description: toolDefinitions.list_accounts.description,
-      inputSchema: toolDefinitions.list_accounts.inputSchema,
-    },
-    async () => {
-      try {
-        return await handleListAccounts();
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-        };
-      }
-    }
-  );
-
-  server.registerTool(
-    "get_otp",
-    {
-      description: toolDefinitions.get_otp.description,
-      inputSchema: toolDefinitions.get_otp.inputSchema,
-    },
-    async (args) => {
-      try {
-        return await handleGetOtp(args as { account_id?: string; account_name?: string });
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-        };
-      }
-    }
-  );
-
-  server.registerTool(
-    "whoami",
-    {
-      description: toolDefinitions.whoami.description,
-      inputSchema: toolDefinitions.whoami.inputSchema,
-    },
-    async () => {
-      try {
-        return await handleWhoami();
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-        };
-      }
-    }
-  );
-
-  // Connect via stdio transport
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
-});

package/src/tools.ts

@@ -1,168 +0,0 @@
-import { z } from "zod";
-import {
-  getTokenInfo,
-  listAccounts,
-  getOtp,
-  findAccountByName,
-  type TokenInfo,
-  type Account,
-  type OtpResponse,
-} from "./client.js";
-
-export const toolDefinitions = {
-  list_accounts: {
-    description:
-      "Returns all 2FA accounts accessible to this token. Use this to see what accounts are available before requesting an OTP code.",
-    inputSchema: z.object({}),
-  },
-  get_otp: {
-    description:
-      "Generates a TOTP code for a specific account. You can provide either the account_id (UUID) or account_name (partial match supported). If multiple accounts match the name, you'll get a list of matches to be more specific.",
-    inputSchema: z.object({
-      account_id: z
-        .uuid()
-        .optional()
-        .describe("UUID of the account"),
-      account_name: z
-        .string()
-        .optional()
-        .describe("Name to search for (partial match)"),
-    }),
-  },
-  whoami: {
-    description:
-      "Returns information about the current token and what it has access to, including the business name, token name, scoped groups, account count, and expiration date.",
-    inputSchema: z.object({}),
-  },
-};
-
-export async function handleListAccounts(): Promise<{
-  content: Array<{ type: "text"; text: string }>;
-}> {
-  const accounts = await listAccounts();
-
-  if (accounts.length === 0) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: "No accounts are accessible with this token.",
-        },
-      ],
-    };
-  }
-
-  const formatted = accounts.map((acc) => ({
-    id: acc.id,
-    name: acc.name,
-    issuer: acc.issuerDomain || null,
-  }));
-
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(formatted, null, 2),
-      },
-    ],
-  };
-}
-
-export async function handleGetOtp(args: {
-  account_id?: string;
-  account_name?: string;
-}): Promise<{ content: Array<{ type: "text"; text: string }> }> {
-  const { account_id, account_name } = args;
-
-  if (!account_id && !account_name) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: "Error: Either account_id or account_name must be provided.",
-        },
-      ],
-    };
-  }
-
-  let targetAccountId: string;
-  let accountName: string;
-
-  if (account_id) {
-    targetAccountId = account_id;
-    // Get the account name for the response
-    const accounts = await listAccounts();
-    const account = accounts.find((a) => a.id === account_id);
-    if (!account) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: Account with ID "${account_id}" not found. Use list_accounts to see available accounts.`,
-          },
-        ],
-      };
-    }
-    accountName = account.name;
-  } else {
-    // Search by name
-    const result = await findAccountByName(account_name!);
-
-    if ("matches" in result) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Multiple accounts match "${account_name}". Please be more specific:\n${result.matches.map((a) => `  - ${a.name} (${a.issuerDomain || "unknown"}) - ID: ${a.id}`).join("\n")}`,
-          },
-        ],
-      };
-    }
-
-    targetAccountId = result.account.id;
-    accountName = result.account.name;
-  }
-
-  const otp = await getOtp(targetAccountId);
-
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            account: accountName,
-            code: otp.code,
-          },
-          null,
-          2
-        ),
-      },
-    ],
-  };
-}
-
-export async function handleWhoami(): Promise<{
-  content: Array<{ type: "text"; text: string }>;
-}> {
-  const info = await getTokenInfo();
-
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            business: info.businessName,
-            token_name: info.tokenName,
-            scoped_groups: info.scopedGroups.map((g) => g.name),
-            account_count: info.accountCount,
-            expires_at: info.expiresAt,
-          },
-          null,
-          2
-        ),
-      },
-    ],
-  };
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsup.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts"],
-  format: ["esm"],
-  dts: true,
-  clean: true,
-  shims: true,
-  banner: {
-    js: "#!/usr/bin/env node",
-  },
-});