opensentinel 3.1.1 → 3.6.1

package/dist/github-KGNILDWJ.js

@@ -0,0 +1,833 @@
+import {
+  Octokit,
+  approvePullRequest,
+  checkMergeability,
+  closePullRequest,
+  convertToDraft,
+  createOctokit,
+  createPullRequest,
+  createReview,
+  createReviewComment,
+  dismissReview,
+  getAuthenticatedUser,
+  getOctokit,
+  getPullRequest,
+  getRateLimit,
+  listCommits,
+  listFiles,
+  listPullRequests,
+  listReviewComments,
+  listReviews,
+  markReadyForReview,
+  mergePullRequest,
+  parseRepoString,
+  removeReviewRequest,
+  reopenPullRequest,
+  replyToReviewComment,
+  requestChanges,
+  requestReviewers,
+  reviewFile,
+  reviewPullRequest,
+  securityScan,
+  submitReview,
+  summarizeChanges,
+  updateBranch,
+  updatePullRequest
+} from "./chunk-HKOPRRDJ.js";
+import "./chunk-HTF2GIQC.js";
+import "./chunk-PUNIMPMY.js";
+import "./chunk-35WYTA3C.js";
+import "./chunk-UP2VWCW5.js";
+
+// src/integrations/github/repos.ts
+async function listRepositories(options = {}, config) {
+  const octokit = getOctokit(config);
+  const { data } = await octokit.rest.repos.listForAuthenticatedUser({
+    type: options.type || "owner",
+    sort: options.sort || "updated",
+    direction: options.direction || "desc",
+    per_page: options.perPage || 30,
+    page: options.page || 1
+  });
+  return data.map(mapRepository);
+}
+async function listOrgRepositories(org, options = {}, config) {
+  const octokit = getOctokit(config);
+  const { data } = await octokit.rest.repos.listForOrg({
+    org,
+    type: options.type || "all",
+    sort: options.sort || "updated",
+    direction: options.direction || "desc",
+    per_page: options.perPage || 30,
+    page: options.page || 1
+  });
+  return data.map(mapRepository);
+}
+async function getRepository(repoString, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.repos.get({ owner, repo });
+  return mapRepository(data);
+}
+async function createRepository(options, config) {
+  const octokit = getOctokit(config);
+  const { data } = await octokit.rest.repos.createForAuthenticatedUser({
+    name: options.name,
+    description: options.description,
+    private: options.private ?? false,
+    auto_init: options.autoInit ?? false,
+    gitignore_template: options.gitignoreTemplate,
+    license_template: options.licenseTemplate,
+    has_issues: options.hasIssues ?? true,
+    has_projects: options.hasProjects ?? true,
+    has_wiki: options.hasWiki ?? true
+  });
+  return mapRepository(data);
+}
+async function createOrgRepository(org, options, config) {
+  const octokit = getOctokit(config);
+  const { data } = await octokit.rest.repos.createInOrg({
+    org,
+    name: options.name,
+    description: options.description,
+    private: options.private ?? false,
+    auto_init: options.autoInit ?? false,
+    gitignore_template: options.gitignoreTemplate,
+    license_template: options.licenseTemplate,
+    has_issues: options.hasIssues ?? true,
+    has_projects: options.hasProjects ?? true,
+    has_wiki: options.hasWiki ?? true
+  });
+  return mapRepository(data);
+}
+async function deleteRepository(repoString, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  await octokit.rest.repos.delete({ owner, repo });
+}
+async function forkRepository(repoString, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.repos.createFork({
+    owner,
+    repo,
+    organization: options?.organization,
+    name: options?.name,
+    default_branch_only: options?.defaultBranchOnly
+  });
+  return mapRepository(data);
+}
+async function listBranches(repoString, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.repos.listBranches({
+    owner,
+    repo,
+    protected: options?.protected,
+    per_page: options?.perPage || 30,
+    page: options?.page || 1
+  });
+  return data.map((branch) => ({
+    name: branch.name,
+    commit: {
+      sha: branch.commit.sha,
+      url: branch.commit.url
+    },
+    protected: branch.protected
+  }));
+}
+async function getContents(repoString, path = "", options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.repos.getContent({
+    owner,
+    repo,
+    path,
+    ref: options?.ref
+  });
+  if (Array.isArray(data)) {
+    return data.map(mapContents);
+  }
+  return mapContents(data);
+}
+async function getCloneInfo(repoString, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.repos.get({ owner, repo });
+  return {
+    httpsUrl: data.clone_url,
+    sshUrl: data.ssh_url,
+    gitUrl: data.git_url,
+    defaultBranch: data.default_branch,
+    size: data.size
+  };
+}
+async function searchRepositories(query, options, config) {
+  const octokit = getOctokit(config);
+  const { data } = await octokit.rest.search.repos({
+    q: query,
+    sort: options?.sort,
+    order: options?.order || "desc",
+    per_page: options?.perPage || 30,
+    page: options?.page || 1
+  });
+  return {
+    totalCount: data.total_count,
+    items: data.items.map(mapRepository)
+  };
+}
+async function getLanguages(repoString, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.repos.listLanguages({ owner, repo });
+  return data;
+}
+async function getContributors(repoString, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.repos.listContributors({
+    owner,
+    repo,
+    per_page: options?.perPage || 30,
+    page: options?.page || 1
+  });
+  return data.filter((c) => c.login !== void 0).map((contributor) => ({
+    login: contributor.login,
+    id: contributor.id,
+    avatarUrl: contributor.avatar_url,
+    contributions: contributor.contributions
+  }));
+}
+function mapRepository(data) {
+  return {
+    id: data.id,
+    name: data.name,
+    fullName: data.full_name,
+    description: data.description,
+    private: data.private,
+    htmlUrl: data.html_url,
+    cloneUrl: data.clone_url,
+    sshUrl: data.ssh_url,
+    defaultBranch: data.default_branch,
+    language: data.language,
+    stargazersCount: data.stargazers_count,
+    forksCount: data.forks_count,
+    openIssuesCount: data.open_issues_count,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at,
+    pushedAt: data.pushed_at,
+    topics: data.topics || [],
+    archived: data.archived,
+    disabled: data.disabled
+  };
+}
+function mapContents(data) {
+  return {
+    type: data.type,
+    name: data.name,
+    path: data.path,
+    sha: data.sha,
+    size: data.size,
+    url: data.url,
+    htmlUrl: data.html_url,
+    downloadUrl: data.download_url,
+    content: data.content,
+    encoding: data.encoding
+  };
+}
+
+// src/integrations/github/issues.ts
+async function listIssues(repoString, options = {}, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.listForRepo({
+    owner,
+    repo,
+    state: options.state || "open",
+    labels: options.labels?.join(","),
+    sort: options.sort || "created",
+    direction: options.direction || "desc",
+    since: options.since,
+    per_page: options.perPage || 30,
+    page: options.page || 1,
+    assignee: options.assignee,
+    creator: options.creator,
+    mentioned: options.mentioned,
+    milestone: options.milestone?.toString()
+  });
+  return data.map(mapIssue);
+}
+async function getIssue(repoString, issueNumber, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.get({
+    owner,
+    repo,
+    issue_number: issueNumber
+  });
+  return mapIssue(data);
+}
+async function createIssue(repoString, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.create({
+    owner,
+    repo,
+    title: options.title,
+    body: options.body,
+    labels: options.labels,
+    assignees: options.assignees,
+    milestone: options.milestone
+  });
+  return mapIssue(data);
+}
+async function updateIssue(repoString, issueNumber, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.update({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    title: options.title,
+    body: options.body,
+    state: options.state,
+    state_reason: options.stateReason,
+    labels: options.labels,
+    assignees: options.assignees,
+    milestone: options.milestone
+  });
+  return mapIssue(data);
+}
+async function closeIssue(repoString, issueNumber, stateReason = "completed", config) {
+  return updateIssue(repoString, issueNumber, {
+    state: "closed",
+    stateReason
+  }, config);
+}
+async function reopenIssue(repoString, issueNumber, config) {
+  return updateIssue(repoString, issueNumber, {
+    state: "open",
+    stateReason: "reopened"
+  }, config);
+}
+async function addLabels(repoString, issueNumber, labels, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.addLabels({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    labels
+  });
+  return data.map((label) => ({
+    id: label.id,
+    name: label.name,
+    color: label.color,
+    description: label.description
+  }));
+}
+async function removeLabel(repoString, issueNumber, label, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  await octokit.rest.issues.removeLabel({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    name: label
+  });
+}
+async function setLabels(repoString, issueNumber, labels, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.setLabels({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    labels
+  });
+  return data.map((label) => ({
+    id: label.id,
+    name: label.name,
+    color: label.color,
+    description: label.description
+  }));
+}
+async function addAssignees(repoString, issueNumber, assignees, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.addAssignees({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    assignees
+  });
+  return mapIssue(data);
+}
+async function removeAssignees(repoString, issueNumber, assignees, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.removeAssignees({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    assignees
+  });
+  return mapIssue(data);
+}
+async function listComments(repoString, issueNumber, options, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.listComments({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    per_page: options?.perPage || 30,
+    page: options?.page || 1,
+    since: options?.since
+  });
+  return data.map(mapComment);
+}
+async function createComment(repoString, issueNumber, body, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.createComment({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    body
+  });
+  return mapComment(data);
+}
+async function updateComment(repoString, commentId, body, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  const { data } = await octokit.rest.issues.updateComment({
+    owner,
+    repo,
+    comment_id: commentId,
+    body
+  });
+  return mapComment(data);
+}
+async function deleteComment(repoString, commentId, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  await octokit.rest.issues.deleteComment({
+    owner,
+    repo,
+    comment_id: commentId
+  });
+}
+async function lockIssue(repoString, issueNumber, lockReason, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  await octokit.rest.issues.lock({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    lock_reason: lockReason
+  });
+}
+async function unlockIssue(repoString, issueNumber, config) {
+  const octokit = getOctokit(config);
+  const { owner, repo } = parseRepoString(repoString);
+  await octokit.rest.issues.unlock({
+    owner,
+    repo,
+    issue_number: issueNumber
+  });
+}
+async function searchIssues(query, options, config) {
+  const octokit = getOctokit(config);
+  const { data } = await octokit.rest.search.issuesAndPullRequests({
+    q: query,
+    sort: options?.sort,
+    order: options?.order || "desc",
+    per_page: options?.perPage || 30,
+    page: options?.page || 1
+  });
+  return {
+    totalCount: data.total_count,
+    items: data.items.map(mapIssue)
+  };
+}
+function mapIssue(data) {
+  return {
+    id: data.id,
+    number: data.number,
+    title: data.title,
+    body: data.body,
+    state: data.state,
+    stateReason: data.state_reason,
+    htmlUrl: data.html_url,
+    user: data.user ? {
+      login: data.user.login,
+      id: data.user.id,
+      avatarUrl: data.user.avatar_url
+    } : null,
+    labels: data.labels.map((label) => ({
+      id: label.id,
+      name: label.name,
+      color: label.color,
+      description: label.description
+    })),
+    assignees: data.assignees?.map((assignee) => ({
+      login: assignee.login,
+      id: assignee.id,
+      avatarUrl: assignee.avatar_url
+    })) || [],
+    milestone: data.milestone ? {
+      id: data.milestone.id,
+      number: data.milestone.number,
+      title: data.milestone.title,
+      state: data.milestone.state
+    } : null,
+    comments: data.comments,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at,
+    closedAt: data.closed_at,
+    isPullRequest: !!data.pull_request
+  };
+}
+function mapComment(data) {
+  return {
+    id: data.id,
+    body: data.body,
+    user: data.user ? {
+      login: data.user.login,
+      id: data.user.id,
+      avatarUrl: data.user.avatar_url
+    } : null,
+    htmlUrl: data.html_url,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at
+  };
+}
+
+// src/integrations/github/webhooks.ts
+import { Webhooks } from "@octokit/webhooks";
+var GitHubWebhooks = class {
+  webhooks;
+  handlers = /* @__PURE__ */ new Map();
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      path: config.path || "/api/github/webhooks"
+    };
+    this.webhooks = new Webhooks({
+      secret: config.secret
+    });
+    this.setupInternalHandlers();
+  }
+  /**
+   * Get the webhook path
+   */
+  get path() {
+    return this.config.path;
+  }
+  /**
+   * Register a handler for a specific event
+   */
+  on(event, handler) {
+    const handlers = this.handlers.get(event) || [];
+    handlers.push(handler);
+    this.handlers.set(event, handlers);
+  }
+  /**
+   * Register a handler for push events
+   */
+  onPush(handler) {
+    this.on("push", handler);
+  }
+  /**
+   * Register a handler for pull request events
+   */
+  onPullRequest(handler) {
+    this.on("pull_request", handler);
+  }
+  /**
+   * Register a handler for issue events
+   */
+  onIssue(handler) {
+    this.on("issues", handler);
+  }
+  /**
+   * Register a handler for issue comment events
+   */
+  onIssueComment(handler) {
+    this.on("issue_comment", handler);
+  }
+  /**
+   * Register a handler for pull request review events
+   */
+  onPullRequestReview(handler) {
+    this.on("pull_request_review", handler);
+  }
+  /**
+   * Register a handler for workflow run events
+   */
+  onWorkflowRun(handler) {
+    this.on("workflow_run", handler);
+  }
+  /**
+   * Register a handler for check suite events
+   */
+  onCheckSuite(handler) {
+    this.on("check_suite", handler);
+  }
+  /**
+   * Register a handler for release events
+   */
+  onRelease(handler) {
+    this.on("release", handler);
+  }
+  /**
+   * Register a handler for star events
+   */
+  onStar(handler) {
+    this.on("star", handler);
+  }
+  /**
+   * Register a handler for fork events
+   */
+  onFork(handler) {
+    this.on("fork", handler);
+  }
+  /**
+   * Handle an incoming webhook event
+   */
+  async handleEvent(eventName, eventId, payload, signature) {
+    const event = {
+      id: eventId,
+      name: eventName,
+      payload,
+      signature,
+      receivedAt: /* @__PURE__ */ new Date()
+    };
+    const handlers = this.handlers.get(eventName) || [];
+    const allHandlers = this.handlers.get("*") || [];
+    const allHandlersToRun = [...handlers, ...allHandlers];
+    await Promise.all(allHandlersToRun.map((handler) => handler(event)));
+  }
+  /**
+   * Verify webhook signature
+   */
+  async verifySignature(payload, signature) {
+    try {
+      return await this.webhooks.verify(payload, signature);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get Hono middleware for handling webhooks
+   */
+  getHonoMiddleware() {
+    return async (c) => {
+      const eventName = c.req.header("x-github-event");
+      const eventId = c.req.header("x-github-delivery");
+      const signature = c.req.header("x-hub-signature-256") || "";
+      if (!eventName || !eventId) {
+        return c.json({ error: "Missing required headers" }, 400);
+      }
+      const payload = await c.req.text();
+      const isValid = await this.verifySignature(payload, signature);
+      if (!isValid) {
+        return c.json({ error: "Invalid signature" }, 401);
+      }
+      try {
+        const parsedPayload = JSON.parse(payload);
+        await this.handleEvent(eventName, eventId, parsedPayload, signature);
+        return c.json({ success: true });
+      } catch (error) {
+        console.error("Webhook handling error:", error);
+        return c.json({ error: "Internal server error" }, 500);
+      }
+    };
+  }
+  /**
+   * Setup internal event handlers for logging/debugging
+   */
+  setupInternalHandlers() {
+    this.on("*", async (event) => {
+      console.log(`[GitHub Webhook] ${event.name} (${event.id})`);
+    });
+  }
+};
+function createWebhookHandler(config) {
+  return new GitHubWebhooks(config);
+}
+function parseRepoFromPayload(payload) {
+  const [owner, repo] = payload.repository.full_name.split("/");
+  return { owner, repo, id: payload.repository.id };
+}
+function formatEventNotification(event) {
+  const payload = event.payload;
+  switch (event.name) {
+    case "push": {
+      const push = payload;
+      const branch = push.ref.replace("refs/heads/", "");
+      const commits = push.commits?.length || 0;
+      return `[${push.repository.full_name}] ${push.pusher.name} pushed ${commits} commit(s) to ${branch}`;
+    }
+    case "pull_request": {
+      const pr = payload;
+      return `[${pr.repository.full_name}] PR #${pr.number} ${pr.action}: "${pr.pull_request.title}" by ${pr.sender.login}`;
+    }
+    case "issues": {
+      const issue = payload;
+      return `[${issue.repository.full_name}] Issue #${issue.issue.number} ${issue.action}: "${issue.issue.title}" by ${issue.sender.login}`;
+    }
+    case "issue_comment": {
+      const comment = payload;
+      return `[${comment.repository.full_name}] Comment on #${comment.issue.number} by ${comment.sender.login}`;
+    }
+    case "pull_request_review": {
+      const review = payload;
+      return `[${review.repository.full_name}] PR #${review.pull_request.number} review ${review.review.state} by ${review.sender.login}`;
+    }
+    case "workflow_run": {
+      const workflow = payload;
+      return `[${workflow.repository.full_name}] Workflow "${workflow.workflow.name}" ${workflow.action}: ${workflow.workflow_run.conclusion || workflow.workflow_run.status}`;
+    }
+    case "release": {
+      const release = payload;
+      return `[${release.repository.full_name}] Release ${release.action}: ${release.release.tag_name}`;
+    }
+    case "star": {
+      const star = payload;
+      return `[${star.repository.full_name}] ${star.sender.login} ${star.action === "created" ? "starred" : "unstarred"} the repository`;
+    }
+    case "fork": {
+      const fork = payload;
+      return `[${fork.repository.full_name}] ${fork.sender.login} forked to ${fork.forkee.full_name}`;
+    }
+    default:
+      return `[GitHub] ${event.name} event received`;
+  }
+}
+function shouldNotify(event, filter) {
+  const payload = event.payload;
+  const action = payload.action;
+  if (filter?.actions && action && !filter.actions.includes(action)) {
+    return false;
+  }
+  if (filter?.excludeActions && action && filter.excludeActions.includes(action)) {
+    return false;
+  }
+  if (event.name === "pull_request" && !filter?.includeDraft) {
+    const pr = payload;
+    if (pr.pull_request.draft) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/integrations/github/index.ts
+var github_default = {
+  // Repository operations
+  listRepositories,
+  getRepository,
+  createRepository,
+  forkRepository,
+  getCloneInfo,
+  // Issue operations
+  listIssues,
+  getIssue,
+  createIssue,
+  updateIssue,
+  closeIssue,
+  createComment,
+  // Pull request operations
+  listPullRequests,
+  getPullRequest,
+  createPullRequest,
+  mergePullRequest,
+  requestReviewers,
+  // Code review
+  reviewPullRequest,
+  summarizeChanges,
+  securityScan,
+  // Webhooks
+  createWebhookHandler,
+  // Utilities
+  getAuthenticatedUser,
+  getRateLimit,
+  parseRepoString
+};
+export {
+  GitHubWebhooks,
+  Octokit,
+  addAssignees,
+  addLabels,
+  approvePullRequest,
+  checkMergeability,
+  closeIssue,
+  closePullRequest,
+  convertToDraft,
+  createComment,
+  createIssue,
+  createOctokit,
+  createOrgRepository,
+  createPullRequest,
+  createRepository,
+  createReview,
+  createReviewComment,
+  createWebhookHandler,
+  github_default as default,
+  deleteComment,
+  deleteRepository,
+  dismissReview,
+  forkRepository,
+  formatEventNotification,
+  getAuthenticatedUser,
+  getCloneInfo,
+  getContents,
+  getContributors,
+  getIssue,
+  getLanguages,
+  getOctokit,
+  getPullRequest,
+  getRateLimit,
+  getRepository,
+  listBranches,
+  listComments,
+  listCommits,
+  listFiles,
+  listIssues,
+  listOrgRepositories,
+  listPullRequests,
+  listRepositories,
+  listReviewComments,
+  listReviews,
+  lockIssue,
+  markReadyForReview,
+  mergePullRequest,
+  parseRepoFromPayload,
+  parseRepoString,
+  removeAssignees,
+  removeLabel,
+  removeReviewRequest,
+  reopenIssue,
+  reopenPullRequest,
+  replyToReviewComment,
+  requestChanges,
+  requestReviewers,
+  reviewFile,
+  reviewPullRequest,
+  searchIssues,
+  searchRepositories,
+  securityScan,
+  setLabels,
+  shouldNotify,
+  submitReview,
+  summarizeChanges,
+  unlockIssue,
+  updateBranch,
+  updateComment,
+  updateIssue,
+  updatePullRequest
+};
+//# sourceMappingURL=github-KGNILDWJ.js.map