@taico/client 0.0.1

package/dist/src/client/services/ToolsService.js

@@ -0,0 +1,336 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class ToolsService {
+    /**
+     * Register a new MCP server
+     * @param requestBody
+     * @returns ServerResponseDto Server created successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerCreateServer(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/mcp/servers',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                409: `Server with providedId already exists`,
+            },
+        });
+    }
+    /**
+     * List all MCP servers with pagination
+     * @param page
+     * @param limit
+     * @returns ServerListResponseDto List of servers
+     * @throws ApiError
+     */
+    static mcpRegistryControllerListServers(page, limit) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/mcp/servers',
+            query: {
+                'page': page,
+                'limit': limit,
+            },
+        });
+    }
+    /**
+     * Get MCP server by UUID or provided ID
+     * @param serverId Server UUID or provided ID
+     * @returns ServerResponseDto Server found
+     * @throws ApiError
+     */
+    static mcpRegistryControllerGetServer(serverId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/mcp/servers/{serverId}',
+            path: {
+                'serverId': serverId,
+            },
+            errors: {
+                404: `Server not found`,
+            },
+        });
+    }
+    /**
+     * Update MCP server details
+     * @param serverId Server UUID
+     * @param requestBody
+     * @returns ServerResponseDto Server updated successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerUpdateServer(serverId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v1/mcp/servers/{serverId}',
+            path: {
+                'serverId': serverId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Server not found`,
+            },
+        });
+    }
+    /**
+     * Delete MCP server (must have no dependencies)
+     * @param serverId Server UUID
+     * @returns DeleteServerResponseDto Server deleted successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerDeleteServer(serverId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v1/mcp/servers/{serverId}',
+            path: {
+                'serverId': serverId,
+            },
+            errors: {
+                404: `Server not found`,
+                409: `Server has dependencies`,
+            },
+        });
+    }
+    /**
+     * Create MCP scope(s) for a server
+     * @param serverId Server UUID
+     * @param requestBody Array of scopes to create
+     * @returns ScopeResponseDto Scope(s) created successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerCreateScopes(serverId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/mcp/servers/{serverId}/scopes',
+            path: {
+                'serverId': serverId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Server not found`,
+                409: `Scope already exists`,
+            },
+        });
+    }
+    /**
+     * List all scopes for an MCP server
+     * @param serverId Server UUID
+     * @returns ScopeResponseDto List of scopes
+     * @throws ApiError
+     */
+    static mcpRegistryControllerListScopes(serverId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/mcp/servers/{serverId}/scopes',
+            path: {
+                'serverId': serverId,
+            },
+            errors: {
+                404: `Server not found`,
+            },
+        });
+    }
+    /**
+     * Get a specific MCP scope
+     * @param serverId Server UUID
+     * @param scopeId Scope ID string
+     * @returns ScopeResponseDto Scope found
+     * @throws ApiError
+     */
+    static mcpRegistryControllerGetScope(serverId, scopeId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/mcp/servers/{serverId}/scopes/{scopeId}',
+            path: {
+                'serverId': serverId,
+                'scopeId': scopeId,
+            },
+            errors: {
+                404: `Scope not found`,
+            },
+        });
+    }
+    /**
+     * Delete MCP scope (must have no mappings)
+     * @param serverId Server UUID
+     * @param scopeId Scope ID string
+     * @returns DeleteScopeResponseDto Scope deleted successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerDeleteScope(serverId, scopeId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v1/mcp/servers/{serverId}/scopes/{scopeId}',
+            path: {
+                'serverId': serverId,
+                'scopeId': scopeId,
+            },
+            errors: {
+                404: `Scope not found`,
+                409: `Scope has mappings`,
+            },
+        });
+    }
+    /**
+     * Create OAuth connection for an MCP server
+     * @param serverId Server UUID
+     * @param requestBody
+     * @returns ConnectionResponseDto Connection created successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerCreateConnection(serverId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/mcp/servers/{serverId}/connections',
+            path: {
+                'serverId': serverId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Server not found`,
+                409: `Connection name conflict`,
+            },
+        });
+    }
+    /**
+     * List all connections for an MCP server
+     * @param serverId Server UUID
+     * @returns ConnectionResponseDto List of connections
+     * @throws ApiError
+     */
+    static mcpRegistryControllerListConnections(serverId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/mcp/servers/{serverId}/connections',
+            path: {
+                'serverId': serverId,
+            },
+            errors: {
+                404: `Server not found`,
+            },
+        });
+    }
+    /**
+     * Get a specific connection
+     * @param connectionId Connection UUID
+     * @returns ConnectionResponseDto Connection found
+     * @throws ApiError
+     */
+    static mcpRegistryControllerGetConnection(connectionId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/mcp/connections/{connectionId}',
+            path: {
+                'connectionId': connectionId,
+            },
+            errors: {
+                404: `Connection not found`,
+            },
+        });
+    }
+    /**
+     * Update connection details
+     * @param connectionId Connection UUID
+     * @param requestBody
+     * @returns ConnectionResponseDto Connection updated successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerUpdateConnection(connectionId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v1/mcp/connections/{connectionId}',
+            path: {
+                'connectionId': connectionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Connection not found`,
+                409: `Connection name conflict`,
+            },
+        });
+    }
+    /**
+     * Delete connection (must have no mappings)
+     * @param connectionId Connection UUID
+     * @returns DeleteConnectionResponseDto Connection deleted successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerDeleteConnection(connectionId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v1/mcp/connections/{connectionId}',
+            path: {
+                'connectionId': connectionId,
+            },
+            errors: {
+                404: `Connection not found`,
+                409: `Connection has mappings`,
+            },
+        });
+    }
+    /**
+     * Create scope mapping
+     * @param serverId Server UUID
+     * @param requestBody
+     * @returns MappingResponseDto Mapping created successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerCreateMapping(serverId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/mcp/servers/{serverId}/mappings',
+            path: {
+                'serverId': serverId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid mapping`,
+                404: `Scope or connection not found`,
+            },
+        });
+    }
+    /**
+     * List downstream scopes for an MCP scope
+     * @param serverId Server UUID
+     * @param scopeId Scope ID string
+     * @returns MappingResponseDto List of mappings
+     * @throws ApiError
+     */
+    static mcpRegistryControllerListMappings(serverId, scopeId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/mcp/servers/{serverId}/scopes/{scopeId}/mappings',
+            path: {
+                'serverId': serverId,
+                'scopeId': scopeId,
+            },
+            errors: {
+                404: `Scope not found`,
+            },
+        });
+    }
+    /**
+     * Delete scope mapping
+     * @param mappingId Mapping UUID
+     * @returns DeleteMappingResponseDto Mapping deleted successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerDeleteMapping(mappingId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v1/mcp/mappings/{mappingId}',
+            path: {
+                'mappingId': mappingId,
+            },
+            errors: {
+                404: `Mapping not found`,
+            },
+        });
+    }
+}

package/dist/src/client/services/WebAuthenticationService.d.ts

@@ -0,0 +1,43 @@
+import type { ChangePasswordRequestDto } from '../models/ChangePasswordRequestDto.js';
+import type { LoginRequestDto } from '../models/LoginRequestDto.js';
+import type { LoginResponseDto } from '../models/LoginResponseDto.js';
+import type { UserResponseDto } from '../models/UserResponseDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class WebAuthenticationService {
+    /**
+     * Login with email and password
+     * @param requestBody
+     * @returns LoginResponseDto Login successful, tokens set in httpOnly cookies
+     * @throws ApiError
+     */
+    static webAuthControllerLogin(requestBody: LoginRequestDto): CancelablePromise<LoginResponseDto>;
+    /**
+     * Refresh access token using refresh token
+     * @returns LoginResponseDto Token refreshed successfully, new tokens set in cookies
+     * @throws ApiError
+     */
+    static webAuthControllerRefresh(): CancelablePromise<LoginResponseDto>;
+    /**
+     * Logout and revoke refresh token
+     * @returns any Logout successful, cookies cleared
+     * @throws ApiError
+     */
+    static webAuthControllerLogout(): CancelablePromise<{
+        ok?: boolean;
+    }>;
+    /**
+     * Get current authenticated user
+     * @returns UserResponseDto Current user information
+     * @throws ApiError
+     */
+    static webAuthControllerMe(): CancelablePromise<UserResponseDto>;
+    /**
+     * Change password for authenticated user
+     * @param requestBody
+     * @returns any Password changed successfully
+     * @throws ApiError
+     */
+    static webAuthControllerChangePassword(requestBody: ChangePasswordRequestDto): CancelablePromise<{
+        ok?: boolean;
+    }>;
+}

package/dist/src/client/services/WebAuthenticationService.js

@@ -0,0 +1,77 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class WebAuthenticationService {
+    /**
+     * Login with email and password
+     * @param requestBody
+     * @returns LoginResponseDto Login successful, tokens set in httpOnly cookies
+     * @throws ApiError
+     */
+    static webAuthControllerLogin(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/login',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Invalid credentials`,
+            },
+        });
+    }
+    /**
+     * Refresh access token using refresh token
+     * @returns LoginResponseDto Token refreshed successfully, new tokens set in cookies
+     * @throws ApiError
+     */
+    static webAuthControllerRefresh() {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/refresh',
+            errors: {
+                401: `Invalid or expired refresh token`,
+            },
+        });
+    }
+    /**
+     * Logout and revoke refresh token
+     * @returns any Logout successful, cookies cleared
+     * @throws ApiError
+     */
+    static webAuthControllerLogout() {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/logout',
+        });
+    }
+    /**
+     * Get current authenticated user
+     * @returns UserResponseDto Current user information
+     * @throws ApiError
+     */
+    static webAuthControllerMe() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/auth/me',
+            errors: {
+                401: `Not authenticated`,
+            },
+        });
+    }
+    /**
+     * Change password for authenticated user
+     * @param requestBody
+     * @returns any Password changed successfully
+     * @throws ApiError
+     */
+    static webAuthControllerChangePassword(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/change-password',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Not authenticated or current password is incorrect`,
+            },
+        });
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client/index.js';
+export * from '../contracts/types.js';

package/dist/src/index.js

@@ -0,0 +1,4 @@
+// Re-export generated client for ergonomics
+export * from './client/index.js';
+// Re-export generated types for ergonomics
+export * from '../contracts/types.js';

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@taico/client",
+  "version": "0.0.1",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js"
+    },
+    "./contracts": {
+      "types": "./dist/contracts/types.d.ts",
+      "import": "./dist/contracts/types.js",
+      "default": "./dist/contracts/types.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:prod": "npm run copy:contracts && npm run generate:types && npm run generate:client && npm run build",
+    "dev": "tsc -w -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.build.json",
+    "lint": "echo \"(shared) lint todo\"",
+    "copy:contracts": "mkdir -p contracts && cp ../../apps/backend/openapi.json contracts/openapi.json",
+    "generate:types": "openapi-typescript contracts/openapi.json -o contracts/types.ts",
+    "generate:client": "openapi --input contracts/openapi.json --output src/client --client fetch && npm run fix:esm-imports",
+    "fix:esm-imports": "node scripts/fix-esm-imports.js"
+  },
+  "devDependencies": {
+    "openapi-typescript": "^7.10.1",
+    "openapi-typescript-codegen": "^0.29.0",
+    "typescript": "^5.6.3"
+  }
+}