Merge pull request #34 from dreamfactorysoftware/feature/add-github-integration

add dreamfactory utility service integration for github to df-mcp cus…

Author: codyllord

config/mcp.php

@@ -1,6 +1,9 @@
 <?php
 
 return [
+    // Cache TTL (seconds) for function bodies fetched from SCM services (GitHub/GitLab/Bitbucket)
+    'scm_cache_ttl' => env('MCP_SCM_CACHE_TTL', 300),
+
     // Daemon configuration
     'daemon' => [
         'enabled' => env('MCP_DAEMON_ENABLED', true),

database/migrations/2026_04_17_000000_add_scm_fields_to_mcp_custom_tools.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+class AddScmFieldsToMcpCustomTools extends Migration
+{
+    public function up()
+    {
+        Schema::table('mcp_custom_tools', function (Blueprint $table) {
+            $table->unsignedInteger('storage_service_id')->nullable()->after('function');
+            $table->string('scm_repository')->nullable()->after('storage_service_id');
+            $table->string('scm_reference')->nullable()->after('scm_repository');
+            $table->string('storage_path')->nullable()->after('scm_reference');
+
+            $table->foreign('storage_service_id')
+                ->references('id')
+                ->on('service')
+                ->onDelete('set null');
+        });
+    }
+
+    public function down()
+    {
+        Schema::table('mcp_custom_tools', function (Blueprint $table) {
+            $table->dropForeign(['storage_service_id']);
+            $table->dropColumn(['storage_service_id', 'scm_repository', 'scm_reference', 'storage_path']);
+        });
+    }
+}

src/Http/Controllers/McpStreamController.php

@@ -4,6 +4,7 @@
 
 use DreamFactory\Core\Http\Controllers\Controller;
 use DreamFactory\Core\McpServer\Client\McpDaemonClient;
+use DreamFactory\Core\McpServer\Models\McpCustomTool;
 use DreamFactory\Core\McpServer\Models\McpOAuthAccessToken;
 use DreamFactory\Core\Enums\ServiceTypeGroups;
 use DreamFactory\Core\Utility\Session as SessionUtilities;
@@ -80,6 +81,11 @@ private function processMcpRequest(Request $request, string $mcpService)
                 $config['custom_tools'][$i]['function'] = $body;
             }
 
+            // Resolve SCM-linked function bodies from GitHub/GitLab/Bitbucket.
+            // Must run before extractFunctionSecrets so secrets.KEY references
+            // in GitHub-hosted code are found and resolved.
+            $this->resolveScmFunctionBodies($config['custom_tools']);
+
             // Scan function bodies for secrets.KEY references, resolve the lookup
             // values, and attach a secrets map so the daemon can inject them at runtime
             // without the values ever appearing in the JS source string.
@@ -153,6 +159,36 @@ private function extractFunctionSecrets(array &$customTools): void
         }
     }
 
+    /**
+     * Resolve function bodies from linked SCM services for function-type custom tools.
+     *
+     * For each tool with a storage_service_id, fetches the function body from the
+     * configured GitHub/GitLab/Bitbucket service and overwrites the function field.
+     * If the fetch fails, the existing inline function body (if any) is kept as fallback.
+     */
+    private function resolveScmFunctionBodies(array &$customTools): void
+    {
+        foreach ($customTools as &$tool) {
+            $toolType = $tool['tool_type'] ?? 'api';
+            $storageServiceId = $tool['storage_service_id'] ?? null;
+
+            if ($toolType !== 'function' || empty($storageServiceId)) {
+                continue;
+            }
+
+            $content = McpCustomTool::resolveScmFunctionBody(
+                $storageServiceId,
+                $tool['scm_repository'] ?? null,
+                $tool['scm_reference'] ?? null,
+                $tool['storage_path'] ?? null
+            );
+
+            if ($content !== null) {
+                $tool['function'] = $content;
+            }
+        }
+    }
+
     /**
      * Get available database and file services, filtered by the user's role.
      *

src/Models/McpCustomTool.php

@@ -2,8 +2,12 @@
 
 namespace DreamFactory\Core\McpServer\Models;
 
+use DreamFactory\Core\Enums\ServiceTypeGroups;
+use DreamFactory\Core\Enums\Verbs;
 use DreamFactory\Core\Models\BaseModel;
 use Illuminate\Database\Eloquent\SoftDeletes;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Log;
 
 class McpCustomTool extends BaseModel
 {
@@ -22,10 +26,15 @@ class McpCustomTool extends BaseModel
         'headers',
         'function',
         'enabled',
+        'storage_service_id',
+        'scm_repository',
+        'scm_reference',
+        'storage_path',
     ];
 
     protected $casts = [
         'service_id' => 'integer',
+        'storage_service_id' => 'integer',
         'parameters' => 'array',
         'headers' => 'array',
         'enabled' => 'boolean',
@@ -98,6 +107,14 @@ public static function syncToolsForService(int $serviceId, array $tools): void
             if (!empty($toolData['id']) && $existing->has($toolData['id'])) {
                 $tool = $existing->get($toolData['id']);
                 $tool->update($toolData);
+                if ($tool->wasChanged(['storage_service_id', 'storage_path', 'scm_repository', 'scm_reference'])) {
+                    Cache::forget(self::buildScmCacheKey(
+                        $tool->storage_service_id,
+                        $tool->scm_repository,
+                        $tool->storage_path,
+                        $tool->scm_reference
+                    ));
+                }
                 $receivedIds[] = $tool->id;
             } else {
                 $tool = static::create($toolData);
@@ -126,6 +143,84 @@ public function toToolDefinition(): array
             'parameters' => $this->parameters ?? [],
             'headers' => !empty($this->headers) ? $this->headers : (object) [],
             'function' => $this->getAttribute('function'),
+            'storage_service_id' => $this->storage_service_id,
+            'scm_repository' => $this->scm_repository,
+            'scm_reference' => $this->scm_reference,
+            'storage_path' => $this->storage_path,
         ];
     }
+
+    /**
+     * Resolve a function body from a linked SCM service (GitHub/GitLab/Bitbucket).
+     *
+     * Uses TTL-based caching to avoid hitting the SCM API on every request.
+     * Returns null if no SCM link is configured or if the fetch fails.
+     */
+    public static function resolveScmFunctionBody(
+        ?int $storageServiceId,
+        ?string $scmRepository,
+        ?string $scmReference,
+        ?string $storagePath
+    ): ?string {
+        if (empty($storageServiceId) || empty($storagePath)) {
+            return null;
+        }
+
+        $cacheKey = self::buildScmCacheKey($storageServiceId, $scmRepository, $storagePath, $scmReference);
+        $ttl = config('mcp.scm_cache_ttl', 300);
+
+        return Cache::remember($cacheKey, $ttl, function () use ($storageServiceId, $scmRepository, $scmReference, $storagePath) {
+            try {
+                $service = \ServiceManager::getServiceById($storageServiceId);
+                $serviceName = $service->getName();
+                $typeGroup = $service->getServiceTypeInfo()->getGroup();
+                $storagePath = trim($storagePath, '/');
+                $scmRef = !empty($scmReference) ? $scmReference : null;
+
+                if ($typeGroup === ServiceTypeGroups::SCM) {
+                    $result = \ServiceManager::handleRequest(
+                        $serviceName,
+                        Verbs::GET,
+                        '_repo/' . $scmRepository,
+                        ['path' => $storagePath, 'branch' => $scmRef, 'content' => 1]
+                    );
+
+                    return $result->getContent();
+                }
+
+                Log::warning('MCP custom tool storage_service_id does not point to an SCM service.', [
+                    'storage_service_id' => $storageServiceId,
+                    'type_group' => $typeGroup,
+                ]);
+
+                return null;
+            } catch (\Exception $e) {
+                Log::warning('Failed to fetch MCP custom tool function from SCM.', [
+                    'storage_service_id' => $storageServiceId,
+                    'scm_repository' => $scmRepository,
+                    'storage_path' => $storagePath,
+                    'error' => $e->getMessage(),
+                ]);
+
+                return null;
+            }
+        });
+    }
+
+    /**
+     * Build a consistent cache key for SCM-sourced function bodies.
+     */
+    private static function buildScmCacheKey(
+        ?int $storageServiceId,
+        ?string $scmRepository,
+        ?string $storagePath,
+        ?string $scmReference
+    ): string {
+        return 'mcp_scm_function:' . implode(':', [
+            $storageServiceId ?? '',
+            $scmRepository ?? '',
+            $storagePath ?? '',
+            $scmReference ?? '',
+        ]);
+    }
 }