@teleporthq/teleport-plugin-next-workflows 0.43.1

package/dist/cjs/nodes/integrations/integration-generic.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGenericIntegration = void 0;
+const escapeForJsString = (s) => s.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\r/g, '\\r').replace(/\n/g, '\\n');
+// PAIRED EDIT: keep in sync with
+//   teleport-services-worker/src/modules/workflow-node-runtime/node-handlers/integrations/_generic.ts
+// The same auth-chain field names and provider-error recogniser must execute
+// in both the test runtime and the published Next.js app.
+const AUTH_FIELD_NAMES = [
+    'apiKey',
+    'token',
+    'accessToken',
+    'secretKey',
+    'authorization',
+    'apiToken',
+    'authToken',
+    'bearerToken',
+    'oauthToken',
+    'serverToken',
+    'rapidApiKey',
+    'projectToken',
+    'tokenValue',
+    'accessKeySecret',
+    'writeKey',
+];
+/**
+ * Generic server integration for WorkflowNodeType entries that use IntegrationNodeConfig.
+ * Serialized handler embeds nodeType (no closure — required for generateHandler() string output).
+ */
+function createGenericIntegration(nodeType) {
+    const fnName = nodeType.replace(/-/g, '_');
+    const ntLiteral = escapeForJsString(nodeType);
+    const authFieldsLiteral = AUTH_FIELD_NAMES.map((f) => `'${f}'`).join(', ');
+    const reservedLiteral = AUTH_FIELD_NAMES.map((f) => `${f}: true`).join(', ');
+    return {
+        nodeType,
+        executionEnv: 'server',
+        secretFields: [...AUTH_FIELD_NAMES],
+        generateHandler() {
+            return `async function ${fnName}(config, context) {
+  var nodeType = '${ntLiteral}';
+  var AUTH_FIELDS = [${authFieldsLiteral}];
+  function extractProviderError(data, text, status) {
+    if (data && typeof data === 'object') {
+      if (data.error && typeof data.error === 'object' && data.error.message) {
+        var code = data.error.code ? ' [' + data.error.code + ']' : '';
+        return data.error.message + code;
+      }
+      if (typeof data.message === 'string' && data.message) {
+        if (data.more_info && typeof data.more_info === 'string') {
+          return data.message + ' (' + data.more_info + ')';
+        }
+        if (Array.isArray(data.errors) && data.errors.length > 0) {
+          var detail = data.errors.map(function (e) {
+            return e && typeof e === 'object' ? (e.message || e.code || JSON.stringify(e)) : String(e);
+          }).join('; ');
+          return data.message + ': ' + detail;
+        }
+        return data.message;
+      }
+      if (Array.isArray(data.errorMessages) && data.errorMessages.length > 0) {
+        return data.errorMessages.join('; ');
+      }
+      if (data.errors && typeof data.errors === 'object' && !Array.isArray(data.errors)) {
+        var parts = Object.keys(data.errors).map(function (k) { return k + ': ' + data.errors[k]; });
+        if (parts.length > 0) { return parts.join('; '); }
+      }
+      if (Array.isArray(data) && data.length > 0 && typeof data[0] === 'object') {
+        var first = data[0];
+        if (typeof first.message === 'string') {
+          var code2 = first.errorCode ? ' [' + first.errorCode + ']' : '';
+          return first.message + code2;
+        }
+      }
+    }
+    var xmlMatch = text && typeof text === 'string' && text.indexOf('<Error>') !== -1 ? text.match(/<Message>([^<]+)<\\/Message>/) : null;
+    if (xmlMatch && xmlMatch[1]) {
+      var codeMatch = text.match(/<Code>([^<]+)<\\/Code>/);
+      return codeMatch ? xmlMatch[1] + ' [' + codeMatch[1] + ']' : xmlMatch[1];
+    }
+    if (typeof text === 'string' && text) { return text; }
+    return 'HTTP ' + status;
+  }
+  var action = config.action;
+  if (!action) {
+    throw new Error(nodeType + ': action is required');
+  }
+  var url = config.url;
+  if (!url) {
+    var base = config.baseUrl || config.apiUrl || config.endpoint;
+    var path = config.path || '';
+    if (base) {
+      var b = String(base).replace(/\\/$/, '');
+      url = path ? b + (String(path).charAt(0) === '/' ? path : '/' + path) : b;
+    }
+  }
+  if (!url || typeof url !== 'string') {
+    throw new Error(nodeType + ': configure url, or baseUrl/apiUrl/endpoint with path');
+  }
+  var method = (config.method || 'POST').toUpperCase();
+  var headers = { 'Content-Type': 'application/json' };
+  if (config.headers && typeof config.headers === 'object' && !Array.isArray(config.headers)) {
+    var hk = Object.keys(config.headers);
+    for (var hi = 0; hi < hk.length; hi++) {
+      headers[hk[hi]] = String(config.headers[hk[hi]]);
+    }
+  }
+  var tok;
+  for (var ai = 0; ai < AUTH_FIELDS.length; ai++) {
+    if (config[AUTH_FIELDS[ai]]) { tok = config[AUTH_FIELDS[ai]]; break; }
+  }
+  if (tok && !headers['Authorization'] && !headers['authorization']) {
+    headers['Authorization'] = 'Bearer ' + tok;
+  }
+  var body = undefined;
+  var reserved = { action: true, outputVariable: true, url: true, method: true, headers: true, body: true,
+    baseUrl: true, apiUrl: true, endpoint: true, path: true, ${reservedLiteral} };
+  if (method !== 'GET' && method !== 'HEAD') {
+    if (config.body !== undefined && config.body !== null) {
+      body = typeof config.body === 'string' ? config.body : JSON.stringify(config.body);
+    } else {
+      var payload = {};
+      var ck = Object.keys(config);
+      for (var ci = 0; ci < ck.length; ci++) {
+        if (!reserved[ck[ci]]) payload[ck[ci]] = config[ck[ci]];
+      }
+      if (Object.keys(payload).length > 0) body = JSON.stringify(payload);
+    }
+  } else {
+    // GET / HEAD: append every non-reserved config key as a query-string
+    // parameter so schema-declared params actually reach the upstream API.
+    // Arrays serialize as repeated key=a&key=b; objects JSON-stringify.
+    var ckg = Object.keys(config);
+    var parts = [];
+    for (var cgi = 0; cgi < ckg.length; cgi++) {
+      var kg = ckg[cgi];
+      if (reserved[kg]) continue;
+      var vg = config[kg];
+      if (vg === undefined || vg === null || vg === '') continue;
+      if (Array.isArray(vg)) {
+        for (var vi = 0; vi < vg.length; vi++) {
+          var item = vg[vi];
+          if (item === undefined || item === null || item === '') continue;
+          parts.push(encodeURIComponent(kg) + '=' + encodeURIComponent(typeof item === 'object' ? JSON.stringify(item) : String(item)));
+        }
+        continue;
+      }
+      var ser = typeof vg === 'object' ? JSON.stringify(vg) : String(vg);
+      parts.push(encodeURIComponent(kg) + '=' + encodeURIComponent(ser));
+    }
+    if (parts.length > 0) {
+      url = url + (url.indexOf('?') === -1 ? '?' : '&') + parts.join('&');
+    }
+  }
+  var res = await fetch(url, { method: method, headers: headers, body: body });
+  var text = await res.text();
+  var data;
+  try { data = text ? JSON.parse(text) : null; } catch (e) { data = text; }
+  if (!res.ok) {
+    var errMsg = extractProviderError(data, text, res.status);
+    return { success: false, error: errMsg, status: res.status, data: data };
+  }
+  return { success: true, data: data, action: action };
+}`;
+        },
+    };
+}
+exports.createGenericIntegration = createGenericIntegration;
+//# sourceMappingURL=integration-generic.js.map

package/dist/cjs/nodes/integrations/integration-generic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-generic.js","sourceRoot":"","sources":["../../../../src/nodes/integrations/integration-generic.ts"],"names":[],"mappings":";;;AAEA,MAAM,iBAAiB,GAAG,CAAC,CAAS,EAAE,EAAE,CACtC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;AAE3F,iCAAiC;AACjC,sGAAsG;AACtG,6EAA6E;AAC7E,0DAA0D;AAC1D,MAAM,gBAAgB,GAAG;IACvB,QAAQ;IACR,OAAO;IACP,aAAa;IACb,WAAW;IACX,eAAe;IACf,UAAU;IACV,WAAW;IACX,aAAa;IACb,YAAY;IACZ,aAAa;IACb,aAAa;IACb,cAAc;IACd,YAAY;IACZ,iBAAiB;IACjB,UAAU;CACX,CAAA;AAED;;;GAGG;AACH,SAAgB,wBAAwB,CAAC,QAAgB;IACvD,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IAC1C,MAAM,SAAS,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAA;IAC7C,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC1E,MAAM,eAAe,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAE5E,OAAO;QACL,QAAQ;QACR,YAAY,EAAE,QAAQ;QACtB,YAAY,EAAE,CAAC,GAAG,gBAAgB,CAAC;QACnC,eAAe;YACb,OAAO,kBAAkB,MAAM;oBACjB,SAAS;uBACN,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DA2EuB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+C5E,CAAA;QACE,CAAC;KACF,CAAA;AACH,CAAC;AA1ID,4DA0IC"}

package/dist/cjs/nodes/integrations/integration-github.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationHandlerGenerator } from '../types';
+export declare const integrationGithub: IntegrationHandlerGenerator;
+//# sourceMappingURL=integration-github.d.ts.map

package/dist/cjs/nodes/integrations/integration-github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-github.d.ts","sourceRoot":"","sources":["../../../../src/nodes/integrations/integration-github.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAmB,MAAM,UAAU,CAAA;AAugBvE,eAAO,MAAM,iBAAiB,EAAE,2BAO/B,CAAA"}

package/dist/cjs/nodes/integrations/integration-github.js

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrationGithub = void 0;
+const types_1 = require("../types");
+async function integration_github(config, context) {
+    // Safely parse a fetch response: providers (Dropbox, Stripe legacy errors,
+    // Slack rate-limit pages, …) sometimes return plain text on failure.
+    // We read once as text and only parse JSON when it actually parses.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const __readJson = async (resp) => {
+        const text = await resp.text();
+        if (!text) {
+            return {};
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch (e) {
+            void e;
+            return { error_summary: text, error: text, message: text, raw: text };
+        }
+    };
+    const accessToken = config.accessToken;
+    const action = config.action;
+    const baseUrl = 'https://api.github.com/';
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/vnd.github+json',
+        Authorization: 'Bearer ' + accessToken,
+        'X-GitHub-Api-Version': '2022-11-28',
+    };
+    switch (action) {
+        case 'create-issue': {
+            const body = {
+                title: config.title,
+                body: config.body || '',
+            };
+            if (config.labels) {
+                body.labels = config.labels;
+            }
+            if (config.assignees) {
+                body.assignees = config.assignees;
+            }
+            if (config.milestone) {
+                body.milestone = config.milestone;
+            }
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/issues', {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+            });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to create issue' };
+            }
+            return { success: true, issue: data };
+        }
+        case 'create-pr': {
+            const body = {
+                title: config.title,
+                head: config.head,
+                base: config.base || 'main',
+                body: config.body || '',
+            };
+            if (config.draft !== undefined) {
+                body.draft = config.draft;
+            }
+            if (config.maintainerCanModify !== undefined) {
+                body.maintainer_can_modify = config.maintainerCanModify;
+            }
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/pulls', {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+            });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to create pull request' };
+            }
+            return { success: true, pullRequest: data };
+        }
+        case 'list-repos': {
+            let url = baseUrl + 'user/repos';
+            const params = [];
+            if (config.type) {
+                params.push('type=' + config.type);
+            }
+            if (config.sort) {
+                params.push('sort=' + config.sort);
+            }
+            if (config.direction) {
+                params.push('direction=' + config.direction);
+            }
+            if (config.perPage) {
+                params.push('per_page=' + config.perPage);
+            }
+            if (config.page) {
+                params.push('page=' + config.page);
+            }
+            if (params.length > 0) {
+                url = url + '?' + params.join('&');
+            }
+            const response = await fetch(url, {
+                method: 'GET',
+                headers,
+            });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to list repos' };
+            }
+            return { success: true, repos: data };
+        }
+        case 'create-repo': {
+            const body = { name: config.name, private: config.private || false };
+            if (config.description) {
+                body.description = config.description;
+            }
+            if (config.autoInit) {
+                body.auto_init = config.autoInit;
+            }
+            const response = await fetch(baseUrl + 'user/repos', {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+            });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to create repo' };
+            }
+            return { success: true, repo: data };
+        }
+        case 'get-repo': {
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo, {
+                method: 'GET',
+                headers,
+            });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to get repo' };
+            }
+            return { success: true, repo: data };
+        }
+        case 'update-repo': {
+            const body = {};
+            if (config.name !== undefined) {
+                body.name = config.name;
+            }
+            if (config.description !== undefined) {
+                body.description = config.description;
+            }
+            if (config.private !== undefined) {
+                body.private = config.private;
+            }
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo, {
+                method: 'PATCH',
+                headers,
+                body: JSON.stringify(body),
+            });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to update repo' };
+            }
+            return { success: true, repo: data };
+        }
+        case 'delete-repo': {
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo, {
+                method: 'DELETE',
+                headers,
+            });
+            if (!response.ok) {
+                const data = await __readJson(response);
+                return { success: false, error: data.message || 'Failed to delete repo' };
+            }
+            return { success: true };
+        }
+        case 'update-issue': {
+            const body = {};
+            if (config.title !== undefined) {
+                body.title = config.title;
+            }
+            if (config.body !== undefined) {
+                body.body = config.body;
+            }
+            if (config.state !== undefined) {
+                body.state = config.state;
+            }
+            if (config.labels) {
+                body.labels = config.labels;
+            }
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/issues/' + config.issueNumber, { method: 'PATCH', headers, body: JSON.stringify(body) });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to update issue' };
+            }
+            return { success: true, issue: data };
+        }
+        case 'close-issue': {
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/issues/' + config.issueNumber, { method: 'PATCH', headers, body: JSON.stringify({ state: 'closed' }) });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to close issue' };
+            }
+            return { success: true, issue: data };
+        }
+        case 'get-issue': {
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/issues/' + config.issueNumber, { method: 'GET', headers });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to get issue' };
+            }
+            return { success: true, issue: data };
+        }
+        case 'list-issues': {
+            let url = baseUrl + 'repos/' + config.owner + '/' + config.repo + '/issues';
+            const params = [];
+            if (config.state) {
+                params.push('state=' + config.state);
+            }
+            if (config.labels) {
+                params.push('labels=' + encodeURIComponent(config.labels));
+            }
+            if (config.perPage) {
+                params.push('per_page=' + config.perPage);
+            }
+            if (config.page) {
+                params.push('page=' + config.page);
+            }
+            if (params.length > 0) {
+                url += '?' + params.join('&');
+            }
+            const response = await fetch(url, { method: 'GET', headers });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to list issues' };
+            }
+            return { success: true, issues: data };
+        }
+        case 'add-issue-comment': {
+            const response = await fetch(baseUrl +
+                'repos/' +
+                config.owner +
+                '/' +
+                config.repo +
+                '/issues/' +
+                config.issueNumber +
+                '/comments', {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ body: config.body }),
+            });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to add comment' };
+            }
+            return { success: true, comment: data };
+        }
+        case 'update-pr': {
+            const body = {};
+            if (config.title !== undefined) {
+                body.title = config.title;
+            }
+            if (config.body !== undefined) {
+                body.body = config.body;
+            }
+            if (config.state !== undefined) {
+                body.state = config.state;
+            }
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/pulls/' + config.pullNumber, { method: 'PATCH', headers, body: JSON.stringify(body) });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to update PR' };
+            }
+            return { success: true, pullRequest: data };
+        }
+        case 'merge-pr': {
+            const body = {};
+            if (config.mergeMethod) {
+                body.merge_method = config.mergeMethod;
+            }
+            const response = await fetch(baseUrl +
+                'repos/' +
+                config.owner +
+                '/' +
+                config.repo +
+                '/pulls/' +
+                config.pullNumber +
+                '/merge', { method: 'PUT', headers, body: JSON.stringify(body) });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to merge PR' };
+            }
+            return { success: true, merge: data };
+        }
+        case 'get-pr': {
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/pulls/' + config.pullNumber, { method: 'GET', headers });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to get PR' };
+            }
+            return { success: true, pullRequest: data };
+        }
+        case 'list-prs': {
+            let url = baseUrl + 'repos/' + config.owner + '/' + config.repo + '/pulls';
+            const params = [];
+            if (config.state) {
+                params.push('state=' + config.state);
+            }
+            if (config.perPage) {
+                params.push('per_page=' + config.perPage);
+            }
+            if (config.page) {
+                params.push('page=' + config.page);
+            }
+            if (params.length > 0) {
+                url += '?' + params.join('&');
+            }
+            const response = await fetch(url, { method: 'GET', headers });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to list PRs' };
+            }
+            return { success: true, pullRequests: data };
+        }
+        case 'create-file': {
+            const content = typeof config.content === 'string' && !config.content.match(/^[A-Za-z0-9+/=]+$/)
+                ? btoa(unescape(encodeURIComponent(config.content)))
+                : config.content || '';
+            const body = { message: config.message, content };
+            if (config.branch) {
+                body.branch = config.branch;
+            }
+            const response = await fetch(baseUrl +
+                'repos/' +
+                config.owner +
+                '/' +
+                config.repo +
+                '/contents/' +
+                encodeURIComponent(config.path), { method: 'PUT', headers, body: JSON.stringify(body) });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to create file' };
+            }
+            return { success: true, file: data };
+        }
+        case 'update-file': {
+            const content = typeof config.content === 'string' && !config.content.match(/^[A-Za-z0-9+/=]+$/)
+                ? btoa(unescape(encodeURIComponent(config.content)))
+                : config.content || '';
+            const body = {
+                message: config.message,
+                content,
+                sha: config.sha,
+            };
+            if (config.branch) {
+                body.branch = config.branch;
+            }
+            const response = await fetch(baseUrl +
+                'repos/' +
+                config.owner +
+                '/' +
+                config.repo +
+                '/contents/' +
+                encodeURIComponent(config.path), { method: 'PUT', headers, body: JSON.stringify(body) });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to update file' };
+            }
+            return { success: true, file: data };
+        }
+        case 'delete-file': {
+            const body = { message: config.message };
+            if (config.branch) {
+                body.branch = config.branch;
+            }
+            if (config.sha) {
+                body.sha = config.sha;
+            }
+            const response = await fetch(baseUrl +
+                'repos/' +
+                config.owner +
+                '/' +
+                config.repo +
+                '/contents/' +
+                encodeURIComponent(config.path), { method: 'DELETE', headers, body: JSON.stringify(body) });
+            if (!response.ok) {
+                const data = await __readJson(response);
+                return { success: false, error: data.message || 'Failed to delete file' };
+            }
+            return { success: true };
+        }
+        case 'get-file': {
+            let fileUrl = baseUrl +
+                'repos/' +
+                config.owner +
+                '/' +
+                config.repo +
+                '/contents/' +
+                encodeURIComponent(config.path);
+            if (config.ref) {
+                fileUrl += '?ref=' + encodeURIComponent(config.ref);
+            }
+            const response = await fetch(fileUrl, { method: 'GET', headers });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to get file' };
+            }
+            return { success: true, file: data };
+        }
+        case 'create-branch': {
+            // Schema canonical name is `branchName`; older workflows used `branch`.
+            // Accept either so the alias removal doesn't break saved workflows.
+            const branchNameVal = config.branchName || config.branch;
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/git/refs', {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ ref: 'refs/heads/' + branchNameVal, sha: config.sha }),
+            });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to create branch' };
+            }
+            return { success: true, ref: data };
+        }
+        case 'create-release': {
+            const body = {
+                tag_name: config.tagName,
+                name: config.name || config.tagName,
+            };
+            if (config.body) {
+                body.body = config.body;
+            }
+            if (config.draft !== undefined) {
+                body.draft = config.draft;
+            }
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/releases', { method: 'POST', headers, body: JSON.stringify(body) });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to create release' };
+            }
+            return { success: true, release: data };
+        }
+        case 'list-releases': {
+            let url = baseUrl + 'repos/' + config.owner + '/' + config.repo + '/releases';
+            if (config.perPage) {
+                url += '?per_page=' + config.perPage;
+            }
+            const response = await fetch(url, { method: 'GET', headers });
+            const data = await __readJson(response);
+            if (!response.ok) {
+                return { success: false, error: data.message || 'Failed to list releases' };
+            }
+            return { success: true, releases: data };
+        }
+        case 'add-collaborator': {
+            const body = {};
+            if (config.permission) {
+                body.permission = config.permission;
+            }
+            const response = await fetch(baseUrl + 'repos/' + config.owner + '/' + config.repo + '/collaborators/' + config.username, {
+                method: 'PUT',
+                headers,
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const data = await __readJson(response);
+                return { success: false, error: data.message || 'Failed to add collaborator' };
+            }
+            return { success: true };
+        }
+        default:
+            throw new Error('Unknown integration-github action: ' + action);
+    }
+}
+exports.integrationGithub = {
+    nodeType: 'integration-github',
+    executionEnv: 'server',
+    secretFields: ['accessToken'],
+    generateHandler() {
+        return (0, types_1.handlerToString)(integration_github);
+    },
+};
+//# sourceMappingURL=integration-github.js.map