feat: MCP tokens section in user settings

src/application/i18n/messages/en.json

@@ -39,6 +39,43 @@
         "title": "Accent theme",
         "caption": "Primary buttons and highlights"
       }
+    },
+    "mcp": {
+      "title": "MCP",
+      "copy": "Copy",
+      "newToken": {
+        "title": "New token",
+        "caption": "Tokens let AI assistants like Claude or Cursor work with your notes via MCP",
+        "labelPlaceholder": "Token name, e.g. Claude Code on laptop",
+        "allowEditing": "Allow editing",
+        "allowEditingCaption": "Without it the assistant can only read notes",
+        "create": "Create token"
+      },
+      "createdToken": {
+        "title": "Your new token",
+        "caption": "Copy it now: you will not be able to see it again"
+      },
+      "instructions": {
+        "claudeCode": "Run in the terminal",
+        "cursor": "Add to ~/.cursor/mcp.json",
+        "claude": "Settings → Connectors → Add custom connector: paste the URL and add the request header"
+      },
+      "permission": {
+        "read": "Read only",
+        "write": "Read and edit"
+      },
+      "tokens": {
+        "title": "Tokens",
+        "caption": "Revoke a token to disconnect the assistant that uses it",
+        "lastUsed": "used {time}",
+        "neverUsed": "never used",
+        "requests": "no requests | {n} request | {n} requests",
+        "loadError": "Could not load tokens",
+        "retry": "Try again",
+        "revoke": "Revoke",
+        "revokeConfirmationTitle": "Revoke token?",
+        "revokeConfirmation": "Assistants using \"{label}\" will lose access to your notes"
+      }
     }
   },
   "noteSettings": {

src/application/services/useUserMcpSettings.ts

@@ -0,0 +1,113 @@
+import type { Ref } from 'vue';
+import { onMounted, ref } from 'vue';
+import type { McpToken, McpTokenPermission } from '@/domain/entities/McpToken';
+import { userSettingsService } from '@/domain';
+
+interface UseUserMcpSettingsComposableState {
+  /**
+   * MCP tokens of the current user, newest first
+   */
+  tokens: Ref<McpToken[]>;
+
+  /**
+   * Whether tokens are being loaded. Tokens should not be created meanwhile:
+   * the loaded list would replace the created token
+   */
+  isLoading: Ref<boolean>;
+
+  /**
+   * Whether tokens failed to load
+   */
+  hasLoadError: Ref<boolean>;
+
+  /**
+   * Loads MCP tokens of the current user
+   */
+  loadTokens(): Promise<void>;
+
+  /**
+   * Creates new MCP token and adds it to the list
+   * @param label - label set by user
+   * @param permission - what MCP client can do with notes
+   * @returns plain token, it is not available later
+   */
+  createToken(label: string, permission: McpTokenPermission): Promise<string>;
+
+  /**
+   * Revokes MCP token and removes it from the list
+   * @param id - token id
+   */
+  revokeToken(id: McpToken['id']): Promise<void>;
+}
+
+/**
+ * Methods for managing MCP tokens of the current user
+ */
+export default function useUserMcpSettings(): UseUserMcpSettingsComposableState {
+  /**
+   * MCP tokens of the current user
+   */
+  const tokens = ref<McpToken[]>([]);
+
+  /**
+   * Whether tokens are being loaded
+   */
+  const isLoading = ref(true);
+
+  /**
+   * Whether tokens failed to load
+   */
+  const hasLoadError = ref(false);
+
+  /**
+   * Loads MCP tokens of the current user
+   */
+  async function loadTokens(): Promise<void> {
+    isLoading.value = true;
+    hasLoadError.value = false;
+
+    try {
+      tokens.value = await userSettingsService.getMcpTokens();
+    } catch {
+      hasLoadError.value = true;
+    } finally {
+      isLoading.value = false;
+    }
+  }
+
+  /**
+   * Creates new MCP token and adds it to the list
+   * @param label - label set by user
+   * @param permission - what MCP client can do with notes
+   */
+  async function createToken(label: string, permission: McpTokenPermission): Promise<string> {
+    const { token, item } = await userSettingsService.createMcpToken(label, permission);
+
+    tokens.value = [item, ...tokens.value];
+
+    return token;
+  }
+
+  /**
+   * Revokes MCP token and removes it from the list
+   * @param id - token id
+   */
+  async function revokeToken(id: McpToken['id']): Promise<void> {
+    await userSettingsService.revokeMcpToken(id);
+
+    tokens.value = tokens.value.filter(token => token.id !== id);
+  }
+
+  onMounted(async () => {
+    await loadTokens();
+  });
+
+  return {
+    tokens,
+    isLoading,
+    hasLoadError,
+    loadTokens,
+    createToken,
+    revokeToken,
+  };
+}

src/domain/entities/McpToken.ts

@@ -0,0 +1,59 @@
+/**
+ * What MCP client can do with notes of the token owner
+ */
+export type McpTokenPermission = 'read' | 'write';
+
+/**
+ * Personal token used by MCP clients (Claude, Cursor, etc.) to access user notes
+ */
+export interface McpToken {
+  /**
+   * Token id
+   */
+  id: number;
+
+  /**
+   * Last characters of the token, used to tell tokens apart
+   */
+  preview: string;
+
+  /**
+   * What MCP client can do with notes of the token owner
+   */
+  permission: McpTokenPermission;
+
+  /**
+   * Label set by user, e.g. "Claude Code on laptop"
+   */
+  label: string;
+
+  /**
+   * Last time token was used to call MCP tool
+   */
+  lastUsedAt: string | null;
+
+  /**
+   * How many times token was used to call MCP tools
+   */
+  requestCount: number;
+
+  /**
+   * When token was created
+   */
+  createdAt: string;
+}
+
+/**
+ * Token returned right after creation. Plain token is shown only once
+ */
+export interface CreatedMcpToken {
+  /**
+   * Plain token to paste into MCP client config
+   */
+  token: string;
+
+  /**
+   * Created token record
+   */
+  item: McpToken;
+}

src/domain/index.ts

@@ -10,6 +10,7 @@ import EditorToolsService from '@/domain/editorTools.service';
 import WorkspaceService from './workspace.service';
 import TeamService from './team.service';
 import NoteHistoryService from './noteHistory.service';
+import UserSettingsService from './userSettings.service';
 /**
  * Get API url from environment
  */
@@ -38,6 +39,7 @@ const userService = new UserService(eventBus, repositories.user);
 const marketplaceService = new MarketplaceService(repositories.marketplace);
 const teamService = new TeamService(repositories.team);
 const noteHistoryService = new NoteHistoryService(repositories.noteHistory);
+const userSettingsService = new UserSettingsService(repositories.userSettings);
 
 /**
  * App State — is a read-only combination of app Stores.
@@ -63,5 +65,6 @@ export {
   marketplaceService,
   workspaceService,
   teamService,
-  noteHistoryService
+  noteHistoryService,
+  userSettingsService
 };

src/domain/userSettings.repository.interface.ts

@@ -0,0 +1,24 @@
+import type { CreatedMcpToken, McpToken, McpTokenPermission } from './entities/McpToken';
+
+/**
+ * Interface of the user settings repository
+ */
+export default interface UserSettingsRepositoryInterface {
+  /**
+   * Loads all MCP tokens of the current user
+   */
+  getMcpTokens(): Promise<McpToken[]>;
+
+  /**
+   * Creates new MCP token
+   * @param label - label set by user
+   * @param permission - what MCP client can do with notes
+   */
+  createMcpToken(label: string, permission: McpTokenPermission): Promise<CreatedMcpToken>;
+
+  /**
+   * Revokes MCP token
+   * @param id - token id
+   */
+  revokeMcpToken(id: McpToken['id']): Promise<void>;
+}

src/domain/userSettings.service.ts

@@ -0,0 +1,41 @@
+import type { CreatedMcpToken, McpToken, McpTokenPermission } from './entities/McpToken';
+import type UserSettingsRepository from './userSettings.repository.interface';
+
+/**
+ * User settings service class, used for logic handling of the data,
+ * Also used for data delivery from repository to application service
+ */
+export default class UserSettingsService {
+  /**
+   * User settings repository instance
+   */
+  private readonly userSettingsRepository: UserSettingsRepository;
+
+  constructor(userSettingsRepository: UserSettingsRepository) {
+    this.userSettingsRepository = userSettingsRepository;
+  }
+
+  /**
+   * Loads all MCP tokens of the current user
+   */
+  public async getMcpTokens(): Promise<McpToken[]> {
+    return await this.userSettingsRepository.getMcpTokens();
+  }
+
+  /**
+   * Creates new MCP token
+   * @param label - label set by user
+   * @param permission - what MCP client can do with notes
+   */
+  public async createMcpToken(label: string, permission: McpTokenPermission): Promise<CreatedMcpToken> {
+    return await this.userSettingsRepository.createMcpToken(label, permission);
+  }
+
+  /**
+   * Revokes MCP token
+   * @param id - token id
+   */
+  public async revokeMcpToken(id: McpToken['id']): Promise<void> {
+    await this.userSettingsRepository.revokeMcpToken(id);
+  }
+}

src/infrastructure/index.ts

@@ -18,6 +18,7 @@ import EditorToolsTransport from '@/infrastructure/transport/editorTools.transpo
 import NoteAttachmentUploaderRepository from './noteAttachmentUploader.repository';
 import TeamRepository from '@/infrastructure/team.repository';
 import NoteHistoryRepository from './noteHistory.repository';
+import UserSettingsRepository from './userSettings.repository';
 
 /**
  * Repositories
@@ -72,6 +73,11 @@ export interface Repositories {
    * Working with note history
    */
   noteHistory: NoteHistoryRepository;
+
+  /**
+   * Working with user settings
+   */
+  userSettings: UserSettingsRepository;
 }
 
 /**
@@ -142,6 +148,7 @@ export function init(noteApiUrl: string, eventBus: EventBus): Repositories {
   const workspaceRepository = new WorkspaceRepository(openedPagesStore);
   const teamRepository = new TeamRepository(notesApiTransport);
   const noteHistoryRepository = new NoteHistoryRepository(notesApiTransport);
+  const userSettingsRepository = new UserSettingsRepository(notesApiTransport);
 
   return {
     note: noteRepository,
@@ -154,5 +161,6 @@ export function init(noteApiUrl: string, eventBus: EventBus): Repositories {
     workspace: workspaceRepository,
     team: teamRepository,
     noteHistory: noteHistoryRepository,
+    userSettings: userSettingsRepository,
   };
 }

src/infrastructure/userSettings.repository.ts

@@ -0,0 +1,49 @@
+import type UserSettingsRepositoryInterface from '@/domain/userSettings.repository.interface';
+import type NotesApiTransport from './transport/notes-api';
+import type { CreatedMcpToken, McpToken, McpTokenPermission } from '@/domain/entities/McpToken';
+
+/**
+ * User settings repository class used for data delivery from transport to service
+ */
+export default class UserSettingsRepository implements UserSettingsRepositoryInterface {
+  /**
+   * Notes api transport instance
+   */
+  private readonly transport: NotesApiTransport;
+
+  constructor(notesApiTransport: NotesApiTransport) {
+    this.transport = notesApiTransport;
+  }
+
+  /**
+   * Loads all MCP tokens of the current user
+   */
+  public async getMcpTokens(): Promise<McpToken[]> {
+    const response = await this.transport.get<{ items: McpToken[] }>('/user/mcp-tokens');
+
+    return response.items;
+  }
+
+  /**
+   * Creates new MCP token
+   * @param label - label set by user
+   * @param permission - what MCP client can do with notes
+   */
+  public async createMcpToken(label: string, permission: McpTokenPermission): Promise<CreatedMcpToken> {
+    return await this.transport.post<CreatedMcpToken>({
+      endpoint: '/user/mcp-tokens',
+      data: {
+        label,
+        permission,
+      },
+    });
+  }
+
+  /**
+   * Revokes MCP token
+   * @param id - token id
+   */
+  public async revokeMcpToken(id: McpToken['id']): Promise<void> {
+    await this.transport.delete<{ isDeleted: boolean }>(`/user/mcp-tokens/${id}`);
+  }
+}