feat: trigger on issue

app/lib/github-app.server.ts

@@ -188,6 +188,24 @@ export class GitHubAppAuth {
   async getInstallationOctokit(installationId: number) {
     return await this.app.getInstallationOctokit(installationId);
   }
+  
+  /**
+   * Get installation by repository owner and name
+   */
+  async getInstallationByRepo(owner: string, repo: string) {
+    try {
+      const appOctokit = await this.app.getOctokit();
+      const { data } = await appOctokit.rest.apps.getRepoInstallation({
+        owner,
+        repo,
+      });
+      
+      return data;
+    } catch (error) {
+      console.error(`Failed to get installation for repository ${owner}/${repo}:`, error);
+      return null;
+    }
+  }
 
   /**
    * Verify webhook signature

app/lib/hugex-service.server.ts

@@ -0,0 +1,235 @@
+import { accountLinkingService } from './account-linking.server';
+import { githubApp } from './github-app.server';
+
+// Default API URL
+const DEFAULT_API_URL = 'https://huggingface-hugex-explore.hf.space/api';
+
+interface HugExRepository {
+  url: string;
+}
+
+interface HugExEnvironment {
+  LLM_MODEL: string;
+  LLM_PROVIDER: string;
+}
+
+interface HugExSecrets {
+  [key: string]: string;
+}
+
+export interface HugExJobCreationParams {
+  title: string;
+  description: string;
+  repository: HugExRepository;
+  branch: string;
+  environment: HugExEnvironment;
+  secrets: HugExSecrets;
+}
+
+export interface HugExJob {
+  id: string;
+  status: string;
+  createdAt: string;
+  title: string;
+  repository: HugExRepository;
+}
+
+export class HugExService {
+  private apiUrl: string;
+
+  constructor() {
+    this.apiUrl = process.env.HUGEX_API_URL || DEFAULT_API_URL;
+    
+    // Log configuration status
+    if (!process.env.HUGEX_API_URL) {
+      console.log(`ℹ️ Using default HugEx API URL: ${this.apiUrl}`);
+    } else {
+      console.log(`✅ HugEx API configured: ${this.apiUrl}`);
+    }
+  }
+
+  /**
+   * Process a GitHub issue to check for @hugex mentions and create jobs
+   */
+  async processGitHubIssue(issue: any, repository: any): Promise<boolean> {
+    try {
+      // Check if issue body contains @hugex mention
+      if (!issue.body || !issue.body.includes('@hugex')) {
+        return false;
+      }
+
+      console.log(`🤖 Found @hugex mention in issue #${issue.number}: ${issue.title}`);
+
+      // Get GitHub user's linked HF account
+      const githubUserId = issue.user.id.toString();
+      const accountLink = accountLinkingService.findByGitHubUser(githubUserId);
+
+      if (!accountLink) {
+        console.log(`⚠️ No linked HuggingFace account found for GitHub user: ${issue.user.login}`);
+        
+        // Comment on the issue to inform the user they need to link their account
+        await this.commentOnIssue(
+          repository.owner.login,
+          repository.name,
+          issue.number,
+          `⚠️ @${issue.user.login}, to use @hugex, you need to link your GitHub account with your HuggingFace account. Please visit the dashboard to complete this process.`
+        );
+        return false;
+      }
+
+      // Extract job parameters from issue body
+      const jobParams = await this.extractJobParamsFromIssue(issue, repository);
+      
+      // Create HugEx job
+      const jobId = await this.createJob(accountLink.huggingfaceUsername, jobParams);
+      
+      if (jobId) {
+        console.log(`✅ Created HugEx job ${jobId} for issue #${issue.number}`);
+        
+        // Comment on the issue with job info
+        await this.commentOnIssue(
+          repository.owner.login,
+          repository.name,
+          issue.number,
+          `🚀 Created HugEx job for this issue. You can track progress at ${this.apiUrl}/jobs/${jobId}`
+        );
+        return true;
+      }
+      
+      return false;
+    } catch (error) {
+      console.error('Error processing GitHub issue for HugEx:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Extract job parameters from issue body
+   */
+  private async extractJobParamsFromIssue(issue: any, repository: any): Promise<HugExJobCreationParams> {
+    // Default values
+    const params: HugExJobCreationParams = {
+      title: issue.title,
+      description: issue.body,
+      repository: {
+        url: repository.html_url
+      },
+      branch: repository.default_branch || 'main',
+      environment: {
+        LLM_MODEL: 'gpt-4',
+        LLM_PROVIDER: 'openai'
+      },
+      secrets: {}
+    };
+
+    // Extract custom parameters if available
+    try {
+      // Look for JSON block in the issue body
+      const jsonMatch = issue.body.match(/```json\s*([\s\S]*?)\s*```/);
+      if (jsonMatch && jsonMatch[1]) {
+        const customParams = JSON.parse(jsonMatch[1]);
+        
+        // Merge with defaults, keeping required structure
+        if (customParams.title) params.title = customParams.title;
+        if (customParams.description) params.description = customParams.description;
+        if (customParams.repository && customParams.repository.url) {
+          params.repository.url = customParams.repository.url;
+        }
+        if (customParams.branch) params.branch = customParams.branch;
+        if (customParams.environment) params.environment = {
+          ...params.environment,
+          ...customParams.environment
+        };
+        if (customParams.secrets) params.secrets = {
+          ...params.secrets,
+          ...customParams.secrets
+        };
+      }
+    } catch (error) {
+      console.warn('Failed to parse custom parameters from issue body:', error);
+      // Continue with default parameters
+    }
+
+    return params;
+  }
+
+  /**
+   * Create a new HugEx job
+   */
+  async createJob(huggingfaceUsername: string, params: HugExJobCreationParams): Promise<string | null> {
+    try {
+      // Get HuggingFace token from persistent storage
+      // Note: In a real implementation, you'd need a secure way to store and retrieve HF tokens
+      // This is a placeholder - you need to implement token storage
+      const hfToken = await this.getHuggingFaceToken(huggingfaceUsername);
+      
+      if (!hfToken) {
+        console.error(`No HuggingFace token available for user: ${huggingfaceUsername}`);
+        return null;
+      }
+
+      const response = await fetch(`${this.apiUrl}/jobs/create-with-key`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${hfToken}`
+        },
+        body: JSON.stringify(params)
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to create HugEx job: ${response.status} - ${errorText}`);
+      }
+
+      const responseData = await response.json();
+      return responseData.id || null;
+    } catch (error) {
+      console.error('Error creating HugEx job:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Comment on a GitHub issue
+   */
+  private async commentOnIssue(owner: string, repo: string, issueNumber: number, body: string): Promise<void> {
+    try {
+      // Get installation Octokit instance for the repository
+      const installation = await githubApp.getInstallationByRepo(owner, repo);
+      if (!installation) {
+        throw new Error(`No GitHub App installation found for repository: ${owner}/${repo}`);
+      }
+
+      const octokit = await githubApp.getInstallationOctokit(installation.id);
+      
+      await octokit.rest.issues.createComment({
+        owner,
+        repo,
+        issue_number: issueNumber,
+        body
+      });
+      
+      console.log(`✅ Posted comment on ${owner}/${repo}#${issueNumber}`);
+    } catch (error) {
+      console.error('Error commenting on GitHub issue:', error);
+    }
+  }
+
+  /**
+   * Get HuggingFace token for a user
+   * Note: This is a placeholder. In a production system, you'd need a secure way to store and retrieve tokens.
+   */
+  private async getHuggingFaceToken(username: string): Promise<string | null> {
+    // In a real implementation, you'd have a secure storage mechanism for tokens
+    // This is a placeholder - you need to implement secure token storage
+    
+    // For now, return null to indicate we don't have a token
+    // This would be replaced with your token retrieval logic
+    console.warn(`⚠️ HuggingFace token storage not implemented. Cannot retrieve token for: ${username}`);
+    return process.env.HF_DEFAULT_TOKEN || null;
+  }
+}
+
+// Singleton instance
+export const hugexService = new HugExService();

app/routes/_index.tsx

@@ -311,30 +311,6 @@ export default function Index() {
               </div>
             )}
           </div>
-
-          {/* Quick Info */}
-          <div className="grid md:grid-cols-3 gap-6 w-full">
-            <div className="bg-white rounded-lg shadow p-6">
-              <h3 className="text-lg font-semibold text-gray-900 mb-2">Why Link Accounts?</h3>
-              <p className="text-gray-600 text-sm">
-                Linking your GitHub and HuggingFace accounts enables seamless integration between the two platforms.
-              </p>
-            </div>
-
-            <div className="bg-white rounded-lg shadow p-6">
-              <h3 className="text-lg font-semibold text-gray-900 mb-2">How It Works</h3>
-              <p className="text-gray-600 text-sm">
-                Simply connect both accounts and we'll automatically link them for you. Your data is stored securely.
-              </p>
-            </div>
-
-            <div className="bg-white rounded-lg shadow p-6">
-              <h3 className="text-lg font-semibold text-gray-900 mb-2">Privacy</h3>
-              <p className="text-gray-600 text-sm">
-                We only store the minimum required information to link your accounts. No sensitive data is kept.
-              </p>
-            </div>
-          </div>
         </div>
       </div>
     </div>

app/routes/webhook.github.tsx

@@ -1,6 +1,7 @@
 import { json } from "@remix-run/node";
 import type { ActionFunctionArgs } from "@remix-run/node";
 import { githubApp } from "~/lib/github-app.server";
+import { hugexService } from "~/lib/hugex-service.server";
 
 export async function action({ request }: ActionFunctionArgs) {
   if (request.method !== "POST") {
@@ -154,6 +155,19 @@ async function handleIssuesEvent(data: any) {
     author: issue.user.login,
   });
 
+  // Process issue for HugEx if action is 'opened' or 'edited'
+  if (['opened', 'edited'].includes(action)) {
+    try {
+      // Check for @hugex mention and create job if found
+      const jobCreated = await hugexService.processGitHubIssue(issue, repository);
+      if (jobCreated) {
+        console.log(`✅ Created HugEx job for issue #${issue.number}`);
+      }
+    } catch (error) {
+      console.error("Error processing issue for HugEx:", error);
+    }
+  }
+
   // Example: Use the issue author's authenticated session
   try {
     const userAuth = githubApp.getUserAuth(issue.user.login);