@codeqr/ts-mcp 0.9.0 → 0.24.0

package/src/logger.ts

@@ -0,0 +1,28 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { pino, type Level, type Logger } from 'pino';
+import pretty from 'pino-pretty';
+
+let _logger: Logger | undefined;
+
+export function configureLogger({ level, pretty: usePretty }: { level: Level; pretty: boolean }): void {
+  _logger = pino(
+    {
+      level,
+      timestamp: pino.stdTimeFunctions.isoTime,
+      formatters: {
+        level(label) {
+          return { level: label };
+        },
+      },
+    },
+    usePretty ? pretty({ colorize: true, levelFirst: true, destination: 2 }) : process.stderr,
+  );
+}
+
+export function getLogger(): Logger {
+  if (!_logger) {
+    throw new Error('Logger has not been configured. Call configureLogger() before using the logger.');
+  }
+  return _logger;
+}

package/src/methods.ts

@@ -0,0 +1,236 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { McpOptions } from './options';
+
+export type SdkMethod = {
+  clientCallName: string;
+  fullyQualifiedName: string;
+  httpMethod?: 'get' | 'post' | 'put' | 'patch' | 'delete' | 'query';
+  httpPath?: string;
+};
+
+export const sdkMethods: SdkMethod[] = [
+  {
+    clientCallName: 'client.links.create',
+    fullyQualifiedName: 'links.create',
+    httpMethod: 'post',
+    httpPath: '/links',
+  },
+  {
+    clientCallName: 'client.links.list',
+    fullyQualifiedName: 'links.list',
+    httpMethod: 'get',
+    httpPath: '/links',
+  },
+  {
+    clientCallName: 'client.links.retrieveInfo',
+    fullyQualifiedName: 'links.retrieveInfo',
+    httpMethod: 'get',
+    httpPath: '/links/info',
+  },
+  {
+    clientCallName: 'client.links.update',
+    fullyQualifiedName: 'links.update',
+    httpMethod: 'put',
+    httpPath: '/links/{linkId}',
+  },
+  {
+    clientCallName: 'client.links.delete',
+    fullyQualifiedName: 'links.delete',
+    httpMethod: 'delete',
+    httpPath: '/links/{linkId}',
+  },
+  {
+    clientCallName: 'client.links.bulk.create',
+    fullyQualifiedName: 'links.bulk.create',
+    httpMethod: 'post',
+    httpPath: '/links/bulk',
+  },
+  {
+    clientCallName: 'client.qrcodes.create',
+    fullyQualifiedName: 'qrcodes.create',
+    httpMethod: 'post',
+    httpPath: '/qrcodes',
+  },
+  {
+    clientCallName: 'client.qrcodes.list',
+    fullyQualifiedName: 'qrcodes.list',
+    httpMethod: 'get',
+    httpPath: '/qrcodes',
+  },
+  {
+    clientCallName: 'client.qrcodes.retrieve',
+    fullyQualifiedName: 'qrcodes.retrieve',
+    httpMethod: 'get',
+    httpPath: '/qrcodes/info',
+  },
+  {
+    clientCallName: 'client.qrcodes.update',
+    fullyQualifiedName: 'qrcodes.update',
+    httpMethod: 'put',
+    httpPath: '/qrcodes/{qrcodeId}',
+  },
+  {
+    clientCallName: 'client.qrcodes.delete',
+    fullyQualifiedName: 'qrcodes.delete',
+    httpMethod: 'delete',
+    httpPath: '/qrcodes/{qrcodeId}',
+  },
+  {
+    clientCallName: 'client.qrcodes.bulk.create',
+    fullyQualifiedName: 'qrcodes.bulk.create',
+    httpMethod: 'post',
+    httpPath: '/qrcodes/bulk',
+  },
+  {
+    clientCallName: 'client.analytics.retrieve',
+    fullyQualifiedName: 'analytics.retrieve',
+    httpMethod: 'get',
+    httpPath: '/analytics',
+  },
+  {
+    clientCallName: 'client.events.list',
+    fullyQualifiedName: 'events.list',
+    httpMethod: 'get',
+    httpPath: '/events',
+  },
+  {
+    clientCallName: 'client.tags.create',
+    fullyQualifiedName: 'tags.create',
+    httpMethod: 'post',
+    httpPath: '/tags',
+  },
+  {
+    clientCallName: 'client.tags.list',
+    fullyQualifiedName: 'tags.list',
+    httpMethod: 'get',
+    httpPath: '/tags',
+  },
+  {
+    clientCallName: 'client.tags.update',
+    fullyQualifiedName: 'tags.update',
+    httpMethod: 'put',
+    httpPath: '/tags/{id}',
+  },
+  {
+    clientCallName: 'client.tags.delete',
+    fullyQualifiedName: 'tags.delete',
+    httpMethod: 'delete',
+    httpPath: '/tags/{id}',
+  },
+  {
+    clientCallName: 'client.domains.create',
+    fullyQualifiedName: 'domains.create',
+    httpMethod: 'post',
+    httpPath: '/domains',
+  },
+  {
+    clientCallName: 'client.domains.list',
+    fullyQualifiedName: 'domains.list',
+    httpMethod: 'get',
+    httpPath: '/domains',
+  },
+  {
+    clientCallName: 'client.domains.update',
+    fullyQualifiedName: 'domains.update',
+    httpMethod: 'patch',
+    httpPath: '/domains/{slug}',
+  },
+  {
+    clientCallName: 'client.domains.delete',
+    fullyQualifiedName: 'domains.delete',
+    httpMethod: 'delete',
+    httpPath: '/domains/{slug}',
+  },
+  {
+    clientCallName: 'client.track.trackLead',
+    fullyQualifiedName: 'track.trackLead',
+    httpMethod: 'post',
+    httpPath: '/track/lead',
+  },
+  {
+    clientCallName: 'client.track.trackSale',
+    fullyQualifiedName: 'track.trackSale',
+    httpMethod: 'post',
+    httpPath: '/track/sale',
+  },
+  {
+    clientCallName: 'client.projects.list',
+    fullyQualifiedName: 'projects.list',
+    httpMethod: 'get',
+    httpPath: '/projects',
+  },
+];
+
+function allowedMethodsForCodeTool(options: McpOptions | undefined): SdkMethod[] | undefined {
+  if (!options) {
+    return undefined;
+  }
+
+  let allowedMethods: SdkMethod[];
+
+  if (options.codeAllowHttpGets || options.codeAllowedMethods) {
+    // Start with nothing allowed and then add into it from options
+    let allowedMethodsSet = new Set<SdkMethod>();
+
+    if (options.codeAllowHttpGets) {
+      // Add all methods that map to an HTTP GET
+      sdkMethods
+        .filter((method) => method.httpMethod === 'get')
+        .forEach((method) => allowedMethodsSet.add(method));
+    }
+
+    if (options.codeAllowedMethods) {
+      // Add all methods that match any of the allowed regexps
+      const allowedRegexps = options.codeAllowedMethods.map((pattern) => {
+        try {
+          return new RegExp(pattern);
+        } catch (e) {
+          throw new Error(
+            `Invalid regex pattern for allowed method: "${pattern}": ${e instanceof Error ? e.message : e}`,
+          );
+        }
+      });
+
+      sdkMethods
+        .filter((method) => allowedRegexps.some((regexp) => regexp.test(method.fullyQualifiedName)))
+        .forEach((method) => allowedMethodsSet.add(method));
+    }
+
+    allowedMethods = Array.from(allowedMethodsSet);
+  } else {
+    // Start with everything allowed
+    allowedMethods = [...sdkMethods];
+  }
+
+  if (options.codeBlockedMethods) {
+    // Filter down based on blocked regexps
+    const blockedRegexps = options.codeBlockedMethods.map((pattern) => {
+      try {
+        return new RegExp(pattern);
+      } catch (e) {
+        throw new Error(
+          `Invalid regex pattern for blocked method: "${pattern}": ${e instanceof Error ? e.message : e}`,
+        );
+      }
+    });
+
+    allowedMethods = allowedMethods.filter(
+      (method) => !blockedRegexps.some((regexp) => regexp.test(method.fullyQualifiedName)),
+    );
+  }
+
+  return allowedMethods;
+}
+
+export function blockedMethodsForCodeTool(options: McpOptions | undefined): SdkMethod[] | undefined {
+  const allowedMethods = allowedMethodsForCodeTool(options);
+  if (!allowedMethods) {
+    return undefined;
+  }
+
+  const allowedSet = new Set(allowedMethods.map((method) => method.fullyQualifiedName));
+
+  // Return any methods that are not explicitly allowed
+  return sdkMethods.filter((method) => !allowedSet.has(method.fullyQualifiedName));
+}