@authn8/mcp-server 1.0.0

package/Dockerfile

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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Authn8
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# @authn8/mcp-server
+
+MCP server that provides AI agents access to Authn8 2FA codes via PAT authentication.
+
+## Prerequisites
+
+- An [Authn8](https://authn8.com) account
+- A Personal Access Token (PAT) created in the Authn8 dashboard
+
+## Quick Start
+
+```bash
+npx @authn8/mcp-server
+```
+
+Set the `AUTHN8_API_KEY` environment variable to your PAT token.
+
+## Docker
+
+```bash
+docker run -e AUTHN8_API_KEY=pat_xxx ghcr.io/authn8/mcp-server
+```
+
+## Configuration
+
+### Claude Desktop
+
+Add to your Claude Desktop configuration file:
+
+**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "authn8": {
+      "command": "npx",
+      "args": ["-y", "@authn8/mcp-server"],
+      "env": {
+        "AUTHN8_API_KEY": "pat_your_token_here"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to your Cursor MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "authn8": {
+      "command": "npx",
+      "args": ["-y", "@authn8/mcp-server"],
+      "env": {
+        "AUTHN8_API_KEY": "pat_your_token_here"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `AUTHN8_API_KEY` | Yes | - | Your PAT token from Authn8 |
+| `AUTHN8_API_URL` | No | `https://api.authn8.com` | API endpoint URL |
+
+## Available Tools
+
+### list_accounts
+
+Returns all 2FA accounts accessible to this token.
+
+**Example response:**
+```json
+[
+  {
+    "id": "924c52a6-4457-4970-a39f-4dc620217683",
+    "name": "AWS Production",
+    "group": "HR",
+    "issuer": "Amazon"
+  }
+]
+```
+
+### get_otp
+
+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)
+
+Provide either `account_id` or `account_name`. If multiple accounts match the name, the tool returns a list of matches.
+
+**Example response:**
+```json
+{
+  "account": "AWS Production",
+  "otp": "483920",
+  "expires_in_seconds": 18
+}
+```
+
+### whoami
+
+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"
+}
+```
+
+## Links
+
+- [Authn8](https://authn8.com) - Create an account and manage 2FA tokens
+- [GitHub Repository](https://github.com/authn8/mcp-server)

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/client.ts
+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 Authn8Error = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "Authn8Error";
+  }
+};
+var accountsCache = null;
+var CACHE_TTL_MS = 60 * 1e3;
+async function apiRequest(endpoint, method = "GET") {
+  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();
+}
+async function getTokenInfo() {
+  return apiRequest("/api/pat/me");
+}
+async function listAccounts() {
+  if (accountsCache && Date.now() - accountsCache.timestamp < CACHE_TTL_MS) {
+    return accountsCache.accounts;
+  }
+  const accounts = await apiRequest("/api/pat/accounts");
+  accountsCache = {
+    accounts,
+    timestamp: Date.now()
+  };
+  return accounts;
+}
+async function getOtp(accountId) {
+  return apiRequest(`/api/pat/otp/${accountId}`);
+}
+async function findAccountByName(name) {
+  const accounts = await listAccounts();
+  const lowerName = name.toLowerCase();
+  const matches = accounts.filter(
+    (acc) => acc.name.toLowerCase().includes(lowerName) || acc.issuer.toLowerCase().includes(lowerName)
+  );
+  if (matches.length === 0) {
+    throw new Authn8Error(
+      `No account found matching "${name}". Available accounts:
+${accounts.map((a) => `  - ${a.name} (${a.issuer})`).join("\n")}`
+    );
+  }
+  if (matches.length === 1) {
+    return { account: matches[0] };
+  }
+  return { matches };
+}
+async function validateToken() {
+  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)}`
+    );
+  }
+}
+
+// src/tools.ts
+import { z } from "zod";
+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({})
+  },
+  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.string().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({})
+  }
+};
+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,
+    group: acc.group,
+    issuer: acc.issuer
+  }));
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(formatted, null, 2)
+      }
+    ]
+  };
+}
+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."
+        }
+      ]
+    };
+  }
+  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.issuer}) - 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,
+            otp: otp.otp,
+            expires_in_seconds: otp.expires_in_seconds
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+async function handleWhoami() {
+  const info = await getTokenInfo();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            business: info.business,
+            token_name: info.token_name,
+            scoped_groups: info.scoped_groups,
+            account_count: info.account_count,
+            expires_at: info.expires_at
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+
+// src/index.ts
+function formatDate(isoDate) {
+  const date = new Date(isoDate);
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function displayStartupInfo(info) {
+  console.error("Authn8 MCP Server");
+  console.error(`Business: ${info.business}`);
+  console.error(`Token: ${info.token_name}`);
+  console.error(`Accounts: ${info.account_count}`);
+  console.error(`Expires: ${formatDate(info.expires_at)}`);
+  console.error("");
+}
+async function main() {
+  let tokenInfo;
+  try {
+    tokenInfo = await validateToken();
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+  displayStartupInfo(tokenInfo);
+  const server = new McpServer({
+    name: "authn8-mcp",
+    version: "1.0.0"
+  });
+  server.tool(
+    "list_accounts",
+    toolDefinitions.list_accounts.description,
+    toolDefinitions.list_accounts.inputSchema.shape,
+    async () => {
+      try {
+        return await handleListAccounts();
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_otp",
+    toolDefinitions.get_otp.description,
+    toolDefinitions.get_otp.inputSchema.shape,
+    async (args) => {
+      try {
+        return await handleGetOtp(args);
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.tool(
+    "whoami",
+    toolDefinitions.whoami.description,
+    toolDefinitions.whoami.inputSchema.shape,
+    async () => {
+      try {
+        return await handleWhoami();
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@authn8/mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for Authn8 2FA code access",
+  "type": "module",
+  "bin": {
+    "authn8-mcp": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "node --loader ts-node/esm src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "keywords": ["mcp", "2fa", "totp", "authn8", "authenticator"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/authn8/mcp-server"
+  },
+  "homepage": "https://authn8.com",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.3",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}

package/src/client.ts

@@ -0,0 +1,153 @@
+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 {
+  business: string;
+  token_name: string;
+  scoped_groups: string[];
+  account_count: number;
+  expires_at: string;
+}
+
+export interface Account {
+  id: string;
+  name: string;
+  group: string;
+  issuer: string;
+}
+
+export interface OtpResponse {
+  account: string;
+  otp: string;
+  expires_in_seconds: 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 accounts = await apiRequest<Account[]>("/api/pat/accounts");
+
+  // Update cache
+  accountsCache = {
+    accounts,
+    timestamp: Date.now(),
+  };
+
+  return 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.issuer.toLowerCase().includes(lowerName)
+  );
+
+  if (matches.length === 0) {
+    throw new Authn8Error(
+      `No account found matching "${name}". Available accounts:\n${accounts.map((a) => `  - ${a.name} (${a.issuer})`).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

@@ -0,0 +1,119 @@
+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.business}`);
+  console.error(`Token: ${info.token_name}`);
+  console.error(`Accounts: ${info.account_count}`);
+  console.error(`Expires: ${formatDate(info.expires_at)}`);
+  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.tool(
+    "list_accounts",
+    toolDefinitions.list_accounts.description,
+    toolDefinitions.list_accounts.inputSchema.shape,
+    async () => {
+      try {
+        return await handleListAccounts();
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+            },
+          ],
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "get_otp",
+    toolDefinitions.get_otp.description,
+    toolDefinitions.get_otp.inputSchema.shape,
+    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.tool(
+    "whoami",
+    toolDefinitions.whoami.description,
+    toolDefinitions.whoami.inputSchema.shape,
+    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

@@ -0,0 +1,171 @@
+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
+        .string()
+        .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,
+    group: acc.group,
+    issuer: acc.issuer,
+  }));
+
+  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.issuer}) - 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,
+            otp: otp.otp,
+            expires_in_seconds: otp.expires_in_seconds,
+          },
+          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.business,
+            token_name: info.token_name,
+            scoped_groups: info.scoped_groups,
+            account_count: info.account_count,
+            expires_at: info.expires_at,
+          },
+          null,
+          2
+        ),
+      },
+    ],
+  };
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "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

@@ -0,0 +1,12 @@
+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",
+  },
+});