@structured-world/gitlab-mcp 5.7.0 → 6.0.0

package/README.md

@@ -14,7 +14,7 @@ This fork is actively maintained and enhanced with strict TypeScript standards,
 
 ## Requirements
 
-- **Node.js**: >=18.0.0 (required for native fetch API support)
+- **Node.js**: >=24.0.0 (required for native fetch with Undici dispatcher pattern)
 - **GitLab**: Compatible with GitLab.com and self-hosted instances
 
 ## Usage
@@ -201,6 +201,251 @@ The GitLab MCP Server automatically selects the appropriate transport mode based
 - Optimal for command-line tools and direct MCP protocol usage
 - Lower resource usage
 
+## TLS/HTTPS Configuration
+
+GitLab MCP Server supports secure HTTPS connections via:
+
+| Approach | Best For | HTTP/2 | Auto-Renewal |
+|----------|----------|--------|--------------|
+| **Direct TLS** | Development, simple deployments | No | Manual |
+| **Reverse Proxy** | Production (recommended) | Yes | Yes |
+
+**Quick Start - Direct TLS:**
+```bash
+docker run -d \
+  -e PORT=3000 \
+  -e SSL_CERT_PATH=/certs/server.crt \
+  -e SSL_KEY_PATH=/certs/server.key \
+  -e GITLAB_TOKEN=your_token \
+  -v $(pwd)/certs:/certs:ro \
+  -p 3000:3000 \
+  ghcr.io/structured-world/gitlab-mcp:latest
+```
+
+**Quick Start - Reverse Proxy (Caddy):**
+```
+gitlab-mcp.example.com {
+    reverse_proxy gitlab-mcp:3002 {
+        flush_interval -1
+    }
+}
+```
+
+For complete setup guides including **nginx**, **Envoy**, **Caddy**, and **Traefik** configurations with HTTP/2 support, see **[SSL.md](SSL.md)**.
+
+## OAuth Authentication (Claude Custom Connector)
+
+GitLab MCP Server supports OAuth 2.1 authentication for use as a **Claude Custom Connector**. This enables secure per-user authentication without sharing GitLab tokens.
+
+### When to Use OAuth Mode
+
+| Scenario | Recommended Mode |
+|----------|------------------|
+| Personal/local use | Static Token (`GITLAB_TOKEN`) |
+| Team access via Claude Web/Desktop | **OAuth Mode** |
+| Private LAN GitLab with public MCP server | **OAuth Mode** |
+| CI/CD or automated pipelines | Static Token |
+
+### Prerequisites
+
+1. **GitLab 17.1+** (Device Authorization Grant support)
+2. **HTTPS endpoint** for gitlab-mcp (required for OAuth)
+3. **GitLab OAuth Application** configured
+
+### Setup Guide
+
+#### Step 1: Create GitLab OAuth Application
+
+1. In GitLab, navigate to **User Settings > Applications** (or **Admin > Applications** for instance-wide)
+2. Create a new application:
+   - **Name**: `GitLab MCP Server`
+   - **Redirect URI**: `https://your-mcp-server.com/oauth/callback` (required for Authorization Code Flow)
+   - **Confidential**: `No` (PKCE provides security without client secret)
+   - **Scopes**: Select `api` and `read_user`
+3. Save and copy the **Application ID**
+
+> **Note**: The redirect URI is used by Claude.ai Custom Connectors (Authorization Code Flow). CLI clients use Device Flow which doesn't require redirect URI.
+
+#### Step 2: Configure gitlab-mcp Server
+
+```bash
+# Required for OAuth mode
+OAUTH_ENABLED=true
+OAUTH_SESSION_SECRET=your-minimum-32-character-secret-key
+GITLAB_OAUTH_CLIENT_ID=your-gitlab-application-id
+GITLAB_API_URL=https://your-gitlab-instance.com
+
+# Server configuration
+PORT=3000
+HOST=0.0.0.0
+
+# Optional OAuth settings
+GITLAB_OAUTH_CLIENT_SECRET=your-secret    # Required only if GitLab app is confidential
+GITLAB_OAUTH_SCOPES=api,read_user          # Default scopes
+OAUTH_TOKEN_TTL=3600                       # Token lifetime (seconds)
+OAUTH_REFRESH_TOKEN_TTL=604800             # Refresh token lifetime (seconds)
+OAUTH_DEVICE_POLL_INTERVAL=5               # Device flow poll interval (seconds)
+OAUTH_DEVICE_TIMEOUT=300                   # Auth timeout (seconds)
+```
+
+#### Step 3: Deploy with HTTPS
+
+OAuth requires HTTPS. Example with Docker:
+
+```bash
+docker run -d \
+  --name gitlab-mcp \
+  -e OAUTH_ENABLED=true \
+  -e OAUTH_SESSION_SECRET="$(openssl rand -base64 32)" \
+  -e GITLAB_OAUTH_CLIENT_ID=your-app-id \
+  -e GITLAB_API_URL=https://gitlab.example.com \
+  -e PORT=3000 \
+  -p 3000:3000 \
+  ghcr.io/structured-world/gitlab-mcp:latest
+```
+
+Use a reverse proxy (nginx, Caddy, Traefik) to add HTTPS.
+
+### Claude Web Setup
+
+1. Go to [claude.ai](https://claude.ai) and sign in
+2. Navigate to **Settings > Connectors**
+3. Click **Add custom connector**
+4. Enter your gitlab-mcp server URL: `https://your-mcp-server.com`
+5. Click **Add**
+6. When prompted, complete authentication:
+   - You'll see a device code (e.g., `ABCD-1234`)
+   - Open your GitLab instance and enter the code
+   - Approve the authorization request
+7. The connector is now active
+
+### Claude Desktop Setup
+
+#### macOS / Linux
+
+Edit `~/.config/claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "gitlab": {
+      "type": "streamable-http",
+      "url": "https://your-mcp-server.com/mcp"
+    }
+  }
+}
+```
+
+#### Windows
+
+Edit `%APPDATA%\Claude\claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "gitlab": {
+      "type": "streamable-http",
+      "url": "https://your-mcp-server.com/mcp"
+    }
+  }
+}
+```
+
+After adding the server:
+1. Restart Claude Desktop
+2. Claude will prompt you to authenticate
+3. Complete the device flow authorization in GitLab
+4. Start using GitLab tools with your personal identity
+
+### Private LAN GitLab Architecture
+
+For GitLab instances on private networks (not internet-accessible):
+
+```
++-------------------+         +-------------------+         +-------------------+
+|   Claude Cloud    |  HTTPS  |    gitlab-mcp     |  HTTP   |   GitLab Server   |
+|   or Desktop      |-------->|   (Public IP)     |-------->|   (Private LAN)   |
++-------------------+         +-------------------+         +-------------------+
+                                       |
+                                       | Device code displayed
+                                       v
+                              +-------------------+
+                              |   User (on VPN)   |
+                              |   visits GitLab   |
+                              |   enters code     |
+                              +-------------------+
+```
+
+**How it works:**
+1. gitlab-mcp server has network access to GitLab (same network or VPN)
+2. User connects to gitlab-mcp via Claude (public internet)
+3. gitlab-mcp initiates device authorization with GitLab
+4. User receives a code and visits GitLab directly (requires VPN/internal access)
+5. User authenticates in GitLab and enters the code
+6. gitlab-mcp receives the token and issues an MCP session token
+7. All subsequent requests use the user's GitLab identity
+
+**Requirements:**
+- gitlab-mcp must reach GitLab API (deploy on same network or use VPN)
+- Users must be able to access GitLab web UI (typically via VPN)
+- gitlab-mcp must be accessible from internet (for Claude to connect)
+
+### OAuth vs Static Token Comparison
+
+| Feature | Static Token | OAuth Mode |
+|---------|--------------|------------|
+| Setup complexity | Simple | Moderate |
+| Per-user identity | No (shared token) | Yes |
+| Token management | Manual | Automatic |
+| Audit trail | Single identity | Per-user actions |
+| Security | Token in config | No tokens in config |
+| Best for | Personal use, CI/CD | Teams, shared access |
+
+### OAuth Flows
+
+The server supports two OAuth flows automatically:
+
+| Flow | Trigger | Used By | How It Works |
+|------|---------|---------|--------------|
+| **Authorization Code Flow** | `redirect_uri` present | Claude.ai Custom Connectors | Redirects to GitLab OAuth, then back to client |
+| **Device Flow** | No `redirect_uri` | CLI clients, Claude Desktop | Shows device code page for manual entry |
+
+The flow is selected automatically based on the presence of `redirect_uri` in the authorization request.
+
+### OAuth Endpoints
+
+When OAuth is enabled, the following endpoints are available:
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/.well-known/oauth-authorization-server` | GET | OAuth metadata discovery |
+| `/.well-known/oauth-protected-resource` | GET | Protected resource metadata (RFC 9470) |
+| `/authorize` | GET | Start authorization (auto-selects flow) |
+| `/oauth/callback` | GET | GitLab callback (Auth Code Flow only) |
+| `/oauth/poll` | GET | Poll for completion (Device Flow only) |
+| `/token` | POST | Exchange code for tokens |
+| `/health` | GET | Health check endpoint |
+
+### Troubleshooting
+
+**"OAuth not configured" error**
+- Ensure `OAUTH_ENABLED=true` is set
+- Verify `OAUTH_SESSION_SECRET` is at least 32 characters
+- Check `GITLAB_OAUTH_CLIENT_ID` is correct
+
+**Device code not accepted**
+- Verify GitLab version is 17.1 or later
+- Check OAuth application scopes include `api`
+- Ensure the application is not set as "Confidential"
+
+**"Failed to refresh token" error**
+- GitLab refresh token may have expired
+- Re-authenticate through Claude connector settings
+
+**Cannot reach GitLab for authentication**
+- For private LAN GitLab, connect to VPN first
+- Verify you can access GitLab web UI in your browser
+
 ### Environment Variables
 
 - `GITLAB_TOKEN`: Your GitLab personal access token.
@@ -221,6 +466,11 @@ The GitLab MCP Server automatically selects the appropriate transport mode based
 - `USE_VARIABLES`: When set to 'true', enables the CI/CD variables-related tools (list_variables, get_variable, create_variable, update_variable, delete_variable). Supports both project-level and group-level variables. By default, variables features are enabled.
 - `GITLAB_AUTH_COOKIE_PATH`: Path to an authentication cookie file for GitLab instances that require cookie-based authentication. When provided, the cookie will be included in all GitLab API requests.
 - `SKIP_TLS_VERIFY`: When set to 'true', skips TLS certificate verification for all GitLab API requests (both REST and GraphQL). **WARNING**: This bypasses SSL certificate validation and should only be used for testing with self-signed certificates or trusted internal GitLab instances. Never use this in production environments.
+- `SSL_CERT_PATH`: Path to PEM certificate file for direct HTTPS/TLS termination. Requires `SSL_KEY_PATH` to also be set.
+- `SSL_KEY_PATH`: Path to PEM private key file for direct HTTPS/TLS termination. Requires `SSL_CERT_PATH` to also be set.
+- `SSL_CA_PATH`: Optional path to CA certificate chain for client certificate validation.
+- `SSL_PASSPHRASE`: Optional passphrase for encrypted private keys.
+- `TRUST_PROXY`: Enable Express trust proxy for reverse proxy deployments. Values: `true`, `false`, `loopback`, `linklocal`, `uniquelocal`, hop count, or specific IP addresses.
 
 ### Dynamic Tool Description Customization
 

package/dist/generated/prisma/client.d.ts

@@ -0,0 +1,13 @@
+import * as runtime from "@prisma/client/runtime/client";
+import * as $Class from "./internal/class";
+import * as Prisma from "./internal/prismaNamespace";
+export * as $Enums from './enums';
+export * from "./enums";
+export declare const PrismaClient: $Class.PrismaClientConstructor;
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>;
+export { Prisma };
+export type OAuthSession = Prisma.OAuthSessionModel;
+export type DeviceFlowState = Prisma.DeviceFlowStateModel;
+export type AuthCodeFlowState = Prisma.AuthCodeFlowStateModel;
+export type AuthorizationCode = Prisma.AuthorizationCodeModel;
+export type McpSessionMapping = Prisma.McpSessionMappingModel;

package/dist/generated/prisma/client.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Prisma = exports.PrismaClient = exports.$Enums = void 0;
+const $Class = __importStar(require("./internal/class"));
+const Prisma = __importStar(require("./internal/prismaNamespace"));
+exports.Prisma = Prisma;
+exports.$Enums = __importStar(require("./enums"));
+__exportStar(require("./enums"), exports);
+exports.PrismaClient = $Class.getPrismaClientClass();
+//# sourceMappingURL=client.js.map

package/dist/generated/prisma/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../generated/prisma/client.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,yDAA0C;AAC1C,mEAAoD;AAmB3C,wBAAM;AAjBf,kDAAiC;AACjC,0CAAuB;AAcV,QAAA,YAAY,GAAG,MAAM,CAAC,oBAAoB,EAAE,CAAA"}

package/dist/generated/prisma/commonInputTypes.d.ts

@@ -0,0 +1,245 @@
+import type * as Prisma from "./internal/prismaNamespace";
+export type StringFilter<$PrismaModel = never> = {
+    equals?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
+    notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
+    lt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    lte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    contains?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    mode?: Prisma.QueryMode;
+    not?: Prisma.NestedStringFilter<$PrismaModel> | string;
+};
+export type BigIntFilter<$PrismaModel = never> = {
+    equals?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    in?: bigint[] | number[] | Prisma.ListBigIntFieldRefInput<$PrismaModel>;
+    notIn?: bigint[] | number[] | Prisma.ListBigIntFieldRefInput<$PrismaModel>;
+    lt?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    lte?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    gt?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    gte?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedBigIntFilter<$PrismaModel> | bigint | number;
+};
+export type IntFilter<$PrismaModel = never> = {
+    equals?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>;
+    notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>;
+    lt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    lte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedIntFilter<$PrismaModel> | number;
+};
+export type StringWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
+    notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
+    lt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    lte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    contains?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    mode?: Prisma.QueryMode;
+    not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedStringFilter<$PrismaModel>;
+    _max?: Prisma.NestedStringFilter<$PrismaModel>;
+};
+export type BigIntWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    in?: bigint[] | number[] | Prisma.ListBigIntFieldRefInput<$PrismaModel>;
+    notIn?: bigint[] | number[] | Prisma.ListBigIntFieldRefInput<$PrismaModel>;
+    lt?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    lte?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    gt?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    gte?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedBigIntWithAggregatesFilter<$PrismaModel> | bigint | number;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _avg?: Prisma.NestedFloatFilter<$PrismaModel>;
+    _sum?: Prisma.NestedBigIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedBigIntFilter<$PrismaModel>;
+    _max?: Prisma.NestedBigIntFilter<$PrismaModel>;
+};
+export type IntWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>;
+    notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>;
+    lt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    lte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedIntWithAggregatesFilter<$PrismaModel> | number;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _avg?: Prisma.NestedFloatFilter<$PrismaModel>;
+    _sum?: Prisma.NestedIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedIntFilter<$PrismaModel>;
+    _max?: Prisma.NestedIntFilter<$PrismaModel>;
+};
+export type StringNullableFilter<$PrismaModel = never> = {
+    equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null;
+    in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null;
+    notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null;
+    lt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    lte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    contains?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    mode?: Prisma.QueryMode;
+    not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null;
+};
+export type SortOrderInput = {
+    sort: Prisma.SortOrder;
+    nulls?: Prisma.NullsOrder;
+};
+export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null;
+    in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null;
+    notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null;
+    lt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    lte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    contains?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    mode?: Prisma.QueryMode;
+    not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null;
+    _count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
+    _min?: Prisma.NestedStringNullableFilter<$PrismaModel>;
+    _max?: Prisma.NestedStringNullableFilter<$PrismaModel>;
+};
+export type NestedStringFilter<$PrismaModel = never> = {
+    equals?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
+    notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
+    lt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    lte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    contains?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedStringFilter<$PrismaModel> | string;
+};
+export type NestedBigIntFilter<$PrismaModel = never> = {
+    equals?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    in?: bigint[] | number[] | Prisma.ListBigIntFieldRefInput<$PrismaModel>;
+    notIn?: bigint[] | number[] | Prisma.ListBigIntFieldRefInput<$PrismaModel>;
+    lt?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    lte?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    gt?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    gte?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedBigIntFilter<$PrismaModel> | bigint | number;
+};
+export type NestedIntFilter<$PrismaModel = never> = {
+    equals?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>;
+    notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>;
+    lt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    lte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedIntFilter<$PrismaModel> | number;
+};
+export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
+    notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>;
+    lt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    lte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    contains?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedStringFilter<$PrismaModel>;
+    _max?: Prisma.NestedStringFilter<$PrismaModel>;
+};
+export type NestedBigIntWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    in?: bigint[] | number[] | Prisma.ListBigIntFieldRefInput<$PrismaModel>;
+    notIn?: bigint[] | number[] | Prisma.ListBigIntFieldRefInput<$PrismaModel>;
+    lt?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    lte?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    gt?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    gte?: bigint | number | Prisma.BigIntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedBigIntWithAggregatesFilter<$PrismaModel> | bigint | number;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _avg?: Prisma.NestedFloatFilter<$PrismaModel>;
+    _sum?: Prisma.NestedBigIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedBigIntFilter<$PrismaModel>;
+    _max?: Prisma.NestedBigIntFilter<$PrismaModel>;
+};
+export type NestedFloatFilter<$PrismaModel = never> = {
+    equals?: number | Prisma.FloatFieldRefInput<$PrismaModel>;
+    in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel>;
+    notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel>;
+    lt?: number | Prisma.FloatFieldRefInput<$PrismaModel>;
+    lte?: number | Prisma.FloatFieldRefInput<$PrismaModel>;
+    gt?: number | Prisma.FloatFieldRefInput<$PrismaModel>;
+    gte?: number | Prisma.FloatFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedFloatFilter<$PrismaModel> | number;
+};
+export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>;
+    notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>;
+    lt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    lte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedIntWithAggregatesFilter<$PrismaModel> | number;
+    _count?: Prisma.NestedIntFilter<$PrismaModel>;
+    _avg?: Prisma.NestedFloatFilter<$PrismaModel>;
+    _sum?: Prisma.NestedIntFilter<$PrismaModel>;
+    _min?: Prisma.NestedIntFilter<$PrismaModel>;
+    _max?: Prisma.NestedIntFilter<$PrismaModel>;
+};
+export type NestedStringNullableFilter<$PrismaModel = never> = {
+    equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null;
+    in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null;
+    notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null;
+    lt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    lte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    contains?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null;
+};
+export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null;
+    in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null;
+    notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null;
+    lt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    lte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gt?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    gte?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    contains?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null;
+    _count?: Prisma.NestedIntNullableFilter<$PrismaModel>;
+    _min?: Prisma.NestedStringNullableFilter<$PrismaModel>;
+    _max?: Prisma.NestedStringNullableFilter<$PrismaModel>;
+};
+export type NestedIntNullableFilter<$PrismaModel = never> = {
+    equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null;
+    in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null;
+    notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null;
+    lt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    lte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gt?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    gte?: number | Prisma.IntFieldRefInput<$PrismaModel>;
+    not?: Prisma.NestedIntNullableFilter<$PrismaModel> | number | null;
+};

package/dist/generated/prisma/commonInputTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=commonInputTypes.js.map

package/dist/generated/prisma/commonInputTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commonInputTypes.js","sourceRoot":"","sources":["../../../generated/prisma/commonInputTypes.ts"],"names":[],"mappings":""}

package/dist/generated/prisma/enums.d.ts

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

package/dist/generated/prisma/enums.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=enums.js.map

package/dist/generated/prisma/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../generated/prisma/enums.ts"],"names":[],"mappings":""}

package/dist/generated/prisma/internal/class.d.ts

@@ -0,0 +1,47 @@
+import * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "./prismaNamespace";
+export type LogOptions<ClientOptions extends Prisma.PrismaClientOptions> = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never;
+export interface PrismaClientConstructor {
+    new <Options extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions, LogOpts extends LogOptions<Options> = LogOptions<Options>, OmitOpts extends Prisma.PrismaClientOptions['omit'] = Options extends {
+        omit: infer U;
+    } ? U : Prisma.PrismaClientOptions['omit'], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs>(options: Prisma.Subset<Options, Prisma.PrismaClientOptions>): PrismaClient<LogOpts, OmitOpts, ExtArgs>;
+}
+export interface PrismaClient<in LogOpts extends Prisma.LogLevel = never, in out OmitOpts extends Prisma.PrismaClientOptions['omit'] = undefined, in out ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> {
+    [K: symbol]: {
+        types: Prisma.TypeMap<ExtArgs>['other'];
+    };
+    $on<V extends LogOpts>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;
+    $connect(): runtime.Types.Utils.JsPromise<void>;
+    $disconnect(): runtime.Types.Utils.JsPromise<void>;
+    $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
+    $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;
+    $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
+    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;
+    $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: {
+        isolationLevel?: Prisma.TransactionIsolationLevel;
+    }): runtime.Types.Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>;
+    $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => runtime.Types.Utils.JsPromise<R>, options?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: Prisma.TransactionIsolationLevel;
+    }): runtime.Types.Utils.JsPromise<R>;
+    $extends: runtime.Types.Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<OmitOpts>, ExtArgs, runtime.Types.Utils.Call<Prisma.TypeMapCb<OmitOpts>, {
+        extArgs: ExtArgs;
+    }>>;
+    get oAuthSession(): Prisma.OAuthSessionDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    get deviceFlowState(): Prisma.DeviceFlowStateDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    get authCodeFlowState(): Prisma.AuthCodeFlowStateDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    get authorizationCode(): Prisma.AuthorizationCodeDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    get mcpSessionMapping(): Prisma.McpSessionMappingDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+}
+export declare function getPrismaClientClass(): PrismaClientConstructor;