n8n-nodes-github-copilot 3.31.30 → 3.32.0

package/dist/credentials/GitHubCopilotApi.credentials.d.ts

@@ -1,9 +1,9 @@
-import { ICredentialType, INodeProperties, ICredentialTestRequest, IAuthenticateGeneric } from "n8n-workflow";
+import { ICredentialType, INodeProperties, ICredentialTestRequest, IHttpRequestOptions, ICredentialDataDecryptedObject } from "n8n-workflow";
 export declare class GitHubCopilotApi implements ICredentialType {
     name: string;
     displayName: string;
     documentationUrl: string;
     properties: INodeProperties[];
-    authenticate: IAuthenticateGeneric;
+    authenticate(credentials: ICredentialDataDecryptedObject, requestOptions: IHttpRequestOptions): Promise<IHttpRequestOptions>;
     test: ICredentialTestRequest;
 }

package/dist/credentials/GitHubCopilotApi.credentials.js

@@ -2,41 +2,97 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubCopilotApi = void 0;
 const GitHubCopilotEndpoints_1 = require("../shared/utils/GitHubCopilotEndpoints");
+const OAuthTokenManager_1 = require("../shared/utils/OAuthTokenManager");
 class GitHubCopilotApi {
     constructor() {
         this.name = "githubCopilotApi";
         this.displayName = "GitHub Copilot API (GitHub CLI Token)";
         this.documentationUrl = "https://docs.github.com/en/copilot/github-copilot-chat/copilot-chat-in-ides/using-github-copilot-chat-in-your-ide";
         this.properties = [
+            {
+                displayName: "Authentication Method",
+                name: "authMethod",
+                type: "options",
+                options: [
+                    {
+                        name: "GitHub CLI Token (Auto OAuth) - RECOMMENDED",
+                        value: "githubToken",
+                        description: "Automatically generates and refreshes OAuth tokens every 20 minutes",
+                    },
+                    {
+                        name: "Manual OAuth Token (Advanced)",
+                        value: "oauthToken",
+                        description: "Manually provide OAuth token (expires in 20 minutes)",
+                    },
+                ],
+                default: "githubToken",
+                description: "Choose how to authenticate with GitHub Copilot API",
+            },
+            {
+                displayName: "ℹ️ Auto OAuth Token Generation",
+                name: "autoOAuthNotice",
+                type: "notice",
+                default: "Your GitHub CLI token will be used to automatically generate OAuth tokens. Tokens are cached and refreshed automatically before expiration (every ~20 minutes). No manual intervention needed!",
+                displayOptions: {
+                    show: {
+                        authMethod: ["githubToken"],
+                    },
+                },
+            },
             {
                 displayName: "⚠️ IMPORTANT: GitHub CLI Token Required",
                 name: "warningNotice",
                 type: "notice",
                 default: "",
+                displayOptions: {
+                    show: {
+                        authMethod: ["githubToken"],
+                    },
+                },
             },
             {
                 displayName: "🚀 Don't have GitHub CLI installed?",
                 name: "helperNotice1",
                 type: "notice",
                 default: "Use the visual 'GitHub Copilot Auth Helper' node to generate your token without touching the terminal!",
+                displayOptions: {
+                    show: {
+                        authMethod: ["githubToken"],
+                    },
+                },
             },
             {
                 displayName: "📝 Step 1: Create Helper Workflow",
                 name: "helperNotice2",
                 type: "notice",
                 default: "Add a new workflow and insert the 'GitHub Copilot Auth Helper' trigger node.",
+                displayOptions: {
+                    show: {
+                        authMethod: ["githubToken"],
+                    },
+                },
             },
             {
                 displayName: "▶️ Step 2: Activate & Access",
                 name: "helperNotice3",
                 type: "notice",
                 default: "Activate the workflow, then click 'Test workflow' to open the visual token generator in your browser.",
+                displayOptions: {
+                    show: {
+                        authMethod: ["githubToken"],
+                    },
+                },
             },
             {
                 displayName: "📋 Step 3: Copy Token",
                 name: "helperNotice4",
                 type: "notice",
                 default: "Follow the on-screen instructions to authenticate with GitHub and copy the generated 'gho_' token back here.",
+                displayOptions: {
+                    show: {
+                        authMethod: ["githubToken"],
+                    },
+                },
             },
             {
                 displayName: "GitHub CLI Token",
@@ -47,20 +103,43 @@ class GitHubCopilotApi {
                 },
                 default: "",
                 required: true,
-                description: "Token generated by GitHub CLI (starts with 'gho_'). Use the Auth Helper node above for easy generation, or run in terminal: gh auth login && gh auth token",
+                description: "Token generated by GitHub CLI (starts with 'gho_'). OAuth tokens will be auto-generated and refreshed from this token.",
                 placeholder: "gho_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+                displayOptions: {
+                    show: {
+                        authMethod: ["githubToken"],
+                    },
+                },
             },
-        ];
-        this.authenticate = {
-            type: "generic",
-            properties: {
-                headers: {
-                    Authorization: "=Bearer {{$credentials.token}}",
-                    Accept: "application/json",
-                    "Content-Type": "application/json",
+            {
+                displayName: "⚠️ Manual OAuth Token (Advanced)",
+                name: "manualOAuthNotice",
+                type: "notice",
+                default: "OAuth tokens expire after ~20 minutes. You will need to manually regenerate and update this token frequently. Consider using GitHub CLI Token mode instead for automatic token management.",
+                displayOptions: {
+                    show: {
+                        authMethod: ["oauthToken"],
+                    },
                 },
             },
-        };
+            {
+                displayName: "OAuth Token",
+                name: "oauthToken",
+                type: "string",
+                typeOptions: {
+                    password: true,
+                },
+                default: "",
+                required: true,
+                description: "Manual OAuth token (starts with 'tid='). Expires in ~20 minutes.",
+                placeholder: "tid=xxxxx;exp=xxxxx;sku=xxxxx;...",
+                displayOptions: {
+                    show: {
+                        authMethod: ["oauthToken"],
+                    },
+                },
+            },
+        ];
         this.test = {
             request: {
                 baseURL: GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.BASE_URL,
@@ -69,5 +148,28 @@ class GitHubCopilotApi {
             },
         };
     }
+    async authenticate(credentials, requestOptions) {
+        const authMethod = credentials.authMethod;
+        let authToken;
+        if (authMethod === "githubToken") {
+            const githubToken = credentials.token;
+            try {
+                authToken = await OAuthTokenManager_1.OAuthTokenManager.getValidOAuthToken(githubToken);
+            }
+            catch (error) {
+                throw new Error(`Failed to generate OAuth token: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            authToken = credentials.oauthToken;
+        }
+        if (!requestOptions.headers) {
+            requestOptions.headers = {};
+        }
+        requestOptions.headers.Authorization = `Bearer ${authToken}`;
+        requestOptions.headers.Accept = "application/json";
+        requestOptions.headers["Content-Type"] = "application/json";
+        return requestOptions;
+    }
 }
 exports.GitHubCopilotApi = GitHubCopilotApi;

package/dist/nodes/GitHubCopilotOpenAI/GitHubCopilotOpenAI.node.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubCopilotOpenAI = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
 const nodeProperties_1 = require("./nodeProperties");
 const utils_1 = require("../GitHubCopilotChatAPI/utils");
 const GitHubCopilotEndpoints_1 = require("../../shared/utils/GitHubCopilotEndpoints");
@@ -282,7 +283,18 @@ class GitHubCopilotOpenAI {
                     }
                     else {
                         const lowerMessage = cleanMessage.toLowerCase();
-                        if (lowerMessage.includes("403") || lowerMessage.includes("forbidden")) {
+                        const is400Error = lowerMessage.includes("400") || lowerMessage.includes("bad request");
+                        if (is400Error) {
+                            errorType = "invalid_request_error";
+                            errorCode = "invalid_request";
+                            finalMessage = cleanMessage;
+                            console.log('🚫 400 Bad Request detected - throwing non-retryable error');
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Bad Request (400): ${finalMessage}`, {
+                                itemIndex: i,
+                                description: 'The request was malformed or contains invalid parameters. Retrying will not help.',
+                            });
+                        }
+                        else if (lowerMessage.includes("403") || lowerMessage.includes("forbidden")) {
                             errorType = "invalid_request_error";
                             errorCode = "insufficient_quota";
                             if (lowerMessage.includes("access") && lowerMessage.includes("forbidden")) {
@@ -303,11 +315,6 @@ class GitHubCopilotOpenAI {
                             errorCode = "invalid_api_key";
                             finalMessage = "Incorrect API key provided. You can find your API key at https://platform.openai.com/account/api-keys.";
                         }
-                        else if (lowerMessage.includes("400") || lowerMessage.includes("bad request")) {
-                            errorType = "invalid_request_error";
-                            errorCode = "invalid_request";
-                            finalMessage = cleanMessage;
-                        }
                         else if (lowerMessage.includes("429") || lowerMessage.includes("rate limit")) {
                             errorType = "rate_limit_error";
                             errorCode = "rate_limit_exceeded";

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-github-copilot",
-    "version": "3.31.30",
+    "version": "3.32.0",
     "description": "n8n community node for GitHub Copilot with CLI integration, Chat API access, and AI Chat Model for workflows - access GPT-5, Claude, Gemini and more using your Copilot subscription",
     "license": "MIT",
     "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",

package/dist/shared/utils/GitHubCopilotApiUtils.js

@@ -10,6 +10,7 @@ exports.estimateTokens = estimateTokens;
 exports.validateTokenLimit = validateTokenLimit;
 exports.truncateToTokenLimit = truncateToTokenLimit;
 const GitHubCopilotEndpoints_1 = require("./GitHubCopilotEndpoints");
+const OAuthTokenManager_1 = require("./OAuthTokenManager");
 async function makeGitHubCopilotRequest(context, endpoint, body, hasMedia = false, retryConfig) {
     var _a, _b, _c, _d;
     const MAX_RETRIES = (_a = retryConfig === null || retryConfig === void 0 ? void 0 : retryConfig.maxRetries) !== null && _a !== void 0 ? _a : 3;
@@ -24,10 +25,44 @@ async function makeGitHubCopilotRequest(context, endpoint, body, hasMedia = fals
     }
     const credentials = await context.getCredentials(credentialType);
     console.log(`🔍 ${credentialType} Credentials Debug:`, Object.keys(credentials));
-    const token = (credentials.accessToken ||
-        credentials.access_token ||
-        ((_d = credentials.oauthTokenData) === null || _d === void 0 ? void 0 : _d.access_token) ||
-        credentials.token);
+    const authMethod = credentials.authMethod;
+    let token;
+    if (authMethod === "githubToken" || credentials.token) {
+        const githubToken = credentials.token;
+        if (!githubToken) {
+            throw new Error("GitHub token (gho_*) not found in credentials");
+        }
+        if (!githubToken.startsWith("gho_")) {
+            throw new Error("Invalid GitHub token format. Must start with gho_");
+        }
+        console.log(`🔄 Using GitHub token to generate OAuth token...`);
+        try {
+            token = await OAuthTokenManager_1.OAuthTokenManager.getValidOAuthToken(githubToken);
+            console.log(`✅ OAuth token ready (auto-generated from GitHub token)`);
+        }
+        catch (error) {
+            throw new Error(`Failed to generate OAuth token: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    else if (authMethod === "oauthToken" || credentials.oauthToken) {
+        token = credentials.oauthToken;
+        if (!token) {
+            throw new Error("OAuth token not found in credentials");
+        }
+        console.log(`✅ Using manual OAuth token`);
+    }
+    else {
+        token = (credentials.accessToken ||
+            credentials.access_token ||
+            ((_d = credentials.oauthTokenData) === null || _d === void 0 ? void 0 : _d.access_token) ||
+            credentials.token);
+        if (!token) {
+            console.error(`❌ Available ${credentialType} credential properties:`, Object.keys(credentials));
+            throw new Error(`No access token found in ${credentialType} credentials. Available properties: ` +
+                Object.keys(credentials).join(", "));
+        }
+        console.log(`⚠️  Using legacy token format (consider updating credential configuration)`);
+    }
     if (!token) {
         console.error(`❌ Available ${credentialType} credential properties:`, Object.keys(credentials));
         console.error(`❌ Full ${credentialType} credential object:`, JSON.stringify(credentials, null, 2));

package/dist/shared/utils/OAuthTokenManager.d.ts

@@ -0,0 +1,19 @@
+interface OAuthTokenCache {
+    token: string;
+    expiresAt: number;
+    generatedAt: number;
+    refreshIn: number;
+}
+export declare class OAuthTokenManager {
+    private static tokenCache;
+    private static machineIdCache;
+    static getValidOAuthToken(githubToken: string): Promise<string>;
+    private static generateOAuthToken;
+    private static getMachineId;
+    private static generateSessionId;
+    private static getCacheKey;
+    static clearCache(githubToken: string): void;
+    static getCacheInfo(githubToken: string): OAuthTokenCache | null;
+    static needsRefresh(githubToken: string, bufferMinutes?: number): boolean;
+}
+export {};

package/dist/shared/utils/OAuthTokenManager.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuthTokenManager = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const https_1 = __importDefault(require("https"));
+class OAuthTokenManager {
+    static async getValidOAuthToken(githubToken) {
+        if (!githubToken || !githubToken.startsWith('gho_')) {
+            throw new Error('Invalid GitHub token. Must start with gho_');
+        }
+        const cacheKey = this.getCacheKey(githubToken);
+        const cached = this.tokenCache.get(cacheKey);
+        if (cached && cached.expiresAt > Date.now() + 120000) {
+            const remainingMinutes = Math.round((cached.expiresAt - Date.now()) / 1000 / 60);
+            console.log(`✅ Using cached OAuth token (${remainingMinutes} minutes remaining)`);
+            return cached.token;
+        }
+        console.log('🔄 Generating new OAuth token...');
+        const newToken = await this.generateOAuthToken(githubToken);
+        return newToken;
+    }
+    static async generateOAuthToken(githubToken) {
+        const machineId = this.getMachineId(githubToken);
+        const sessionId = this.generateSessionId();
+        return new Promise((resolve, reject) => {
+            const options = {
+                hostname: 'api.github.com',
+                path: '/copilot_internal/v2/token',
+                method: 'GET',
+                headers: {
+                    'Authorization': `token ${githubToken}`,
+                    'Vscode-Machineid': machineId,
+                    'Vscode-Sessionid': sessionId,
+                    'Editor-Version': 'vscode/1.105.1',
+                    'Editor-Plugin-Version': 'copilot-chat/0.32.3',
+                    'X-GitHub-Api-Version': '2025-08-20',
+                    'Accept': 'application/json',
+                    'User-Agent': 'n8n-nodes-copilot/1.0.0',
+                },
+            };
+            const req = https_1.default.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => (data += chunk));
+                res.on('end', () => {
+                    if (res.statusCode === 200) {
+                        try {
+                            const response = JSON.parse(data);
+                            const oauthToken = response.token;
+                            const expiresAt = response.expires_at * 1000;
+                            const refreshIn = response.refresh_in;
+                            const cacheKey = this.getCacheKey(githubToken);
+                            this.tokenCache.set(cacheKey, {
+                                token: oauthToken,
+                                expiresAt: expiresAt,
+                                generatedAt: Date.now(),
+                                refreshIn: refreshIn,
+                            });
+                            const expiresInMinutes = Math.round((expiresAt - Date.now()) / 1000 / 60);
+                            console.log(`✅ OAuth token generated successfully (expires in ${expiresInMinutes} minutes)`);
+                            resolve(oauthToken);
+                        }
+                        catch (error) {
+                            reject(new Error(`Failed to parse OAuth token response: ${error}`));
+                        }
+                    }
+                    else {
+                        reject(new Error(`Failed to generate OAuth token: ${res.statusCode} ${res.statusMessage}`));
+                    }
+                });
+            });
+            req.on('error', (error) => {
+                reject(new Error(`Network error generating OAuth token: ${error.message}`));
+            });
+            req.setTimeout(10000, () => {
+                req.destroy();
+                reject(new Error('OAuth token generation timeout'));
+            });
+            req.end();
+        });
+    }
+    static getMachineId(githubToken) {
+        const cacheKey = this.getCacheKey(githubToken);
+        if (!this.machineIdCache.has(cacheKey)) {
+            const uuid = crypto_1.default.randomUUID();
+            const machineId = crypto_1.default.createHash('sha256').update(uuid).digest('hex');
+            this.machineIdCache.set(cacheKey, machineId);
+            console.log('🆔 Generated new machine ID');
+        }
+        return this.machineIdCache.get(cacheKey);
+    }
+    static generateSessionId() {
+        return `${crypto_1.default.randomUUID()}${Date.now()}`;
+    }
+    static getCacheKey(githubToken) {
+        return githubToken.substring(0, 20);
+    }
+    static clearCache(githubToken) {
+        const cacheKey = this.getCacheKey(githubToken);
+        this.tokenCache.delete(cacheKey);
+        this.machineIdCache.delete(cacheKey);
+        console.log('🗑️ OAuth token cache cleared');
+    }
+    static getCacheInfo(githubToken) {
+        const cacheKey = this.getCacheKey(githubToken);
+        return this.tokenCache.get(cacheKey) || null;
+    }
+    static needsRefresh(githubToken, bufferMinutes = 2) {
+        const cacheKey = this.getCacheKey(githubToken);
+        const cached = this.tokenCache.get(cacheKey);
+        if (!cached)
+            return true;
+        const bufferMs = bufferMinutes * 60 * 1000;
+        return cached.expiresAt <= Date.now() + bufferMs;
+    }
+}
+exports.OAuthTokenManager = OAuthTokenManager;
+OAuthTokenManager.tokenCache = new Map();
+OAuthTokenManager.machineIdCache = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.31.30",
+  "version": "3.32.0",
   "description": "n8n community node for GitHub Copilot with CLI integration, Chat API access, and AI Chat Model for workflows - access GPT-5, Claude, Gemini and more using your Copilot subscription",
   "license": "MIT",
   "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",