@dual-os/github-api 0.0.0-stage → 6.0.5

package/plugin-p6f7n836.js

@@ -0,0 +1,631 @@
+// @bun
+import {
+  pipeArguments,
+  dual,
+  pipe,
+  hash,
+  equals,
+  format,
+  NodeInspectSymbol,
+  toJson,
+  PipeInspectableProto,
+  withFiber,
+  none,
+  some,
+  isSome,
+  match2,
+  getOrElse,
+  orElse,
+  map,
+  flatMap,
+  Service,
+  merge,
+  getSuccess,
+  takeRight,
+  contains,
+  flatten,
+  filter2,
+  every,
+  fromInputUnsafe,
+  isFinite,
+  isZero,
+  zero,
+  infinity,
+  millis,
+  toMillis,
+  fiberJoin,
+  fiberInterrupt,
+  succeed2,
+  sync,
+  void_,
+  exitHasInterrupts,
+  updateContext,
+  contextWith,
+  onExitUnsafe,
+  forkUnsafe,
+  ClockRef,
+  isSuccess2,
+  effect,
+  currentTimeMillis,
+  min,
+  replace,
+  trim,
+  startsWith,
+  endsWith,
+  replaceAll,
+  forEach,
+  succeed5,
+  void_3,
+  gen,
+  fail5,
+  try_2,
+  fromOption2,
+  flatMap3,
+  asSome,
+  catchTag,
+  mapError2,
+  timeout,
+  provideService,
+  fnUntraced,
+  fn,
+  decode2,
+  encode3,
+  toEpochMillis,
+  decodeUnknownOption,
+  encodeEffect,
+  optionalKey,
+  Literal,
+  String3,
+  Struct,
+  ArraySchema,
+  NullOr,
+  Int,
+  Natural,
+  NonEmptyString,
+  fromJsonString,
+  DateTimeUtcFromString,
+  value2,
+  when,
+  orElse2,
+  exhaustive,
+  get3,
+  post,
+  patch,
+  del,
+  setHeaders,
+  bearerToken,
+  prependUrl,
+  setUrlParams,
+  bodyJsonUnsafe,
+  schemaBodyJson,
+  HttpClient,
+  mapRequest,
+  RequestInit,
+  AgentChannel_exports
+} from "./plugin-w0va8331.js";
+import {
+  apiVersion2,
+  Permission2
+} from "./plugin-2qqpmr67.js";
+import {
+  NumericId2
+} from "./plugin-7hfrx1dg.js";
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/MutableHashMap.js
+var TypeId = "~effect/MutableHashMap";
+var MutableHashMapProto = {
+  [TypeId]: TypeId,
+  [Symbol.iterator]() {
+    return this.backing[Symbol.iterator]();
+  },
+  toString() {
+    return `MutableHashMap(${format(Array.from(this))})`;
+  },
+  toJSON() {
+    return {
+      _id: "MutableHashMap",
+      values: toJson(Array.from(this))
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var empty = () => {
+  const self = Object.create(MutableHashMapProto);
+  self.backing = new Map;
+  self.buckets = new Map;
+  return self;
+};
+var make = (...entries) => fromIterable(entries);
+var fromIterable = (entries) => {
+  const self = empty();
+  for (const [key, value] of entries) {
+    set(self, key, value);
+  }
+  return self;
+};
+var get = /* @__PURE__ */ dual(2, (self, key) => {
+  if (self.backing.has(key)) {
+    return some(self.backing.get(key));
+  } else if (isSimpleKey(key)) {
+    return none();
+  }
+  const hash2 = hash(key);
+  const bucket = self.buckets.get(hash2);
+  if (bucket === undefined) {
+    return none();
+  }
+  return getFromBucket(self, bucket, key);
+});
+var isSimpleKey = (u) => typeof u !== "object" && typeof u !== "function";
+var getFromBucket = (self, bucket, key) => {
+  for (let i = 0, len = bucket.length;i < len; i++) {
+    if (equals(key, bucket[i])) {
+      const refKey = bucket[i];
+      return some(self.backing.get(refKey));
+    }
+  }
+  return none();
+};
+var set = /* @__PURE__ */ dual(3, (self, key, value) => {
+  if (self.backing.has(key) || isSimpleKey(key)) {
+    self.backing.set(key, value);
+    return self;
+  }
+  const hash2 = hash(key);
+  const bucket = self.buckets.get(hash2);
+  if (bucket === undefined) {
+    self.buckets.set(hash2, [key]);
+    self.backing.set(key, value);
+    return self;
+  }
+  let refKey = getRefKey(bucket, key);
+  if (refKey === undefined) {
+    bucket.push(key);
+    refKey = key;
+  }
+  self.backing.set(refKey, value);
+  return self;
+});
+var getRefKey = (bucket, key) => {
+  for (let i = 0, len = bucket.length;i < len; i++) {
+    if (equals(key, bucket[i])) {
+      return bucket[i];
+    }
+  }
+};
+var remove = /* @__PURE__ */ dual(2, (self, key_) => {
+  if (isSimpleKey(key_)) {
+    self.backing.delete(key_);
+    return self;
+  }
+  const hash2 = hash(key_);
+  const bucket = self.buckets.get(hash2);
+  if (bucket === undefined) {
+    return self;
+  }
+  for (let i = 0, len = bucket.length;i < len; i++) {
+    const bkey = bucket[i];
+    if (bkey === key_ || equals(key_, bkey)) {
+      self.backing.delete(bkey);
+      bucket.splice(i, 1);
+      break;
+    }
+  }
+  if (bucket.length === 0) {
+    self.buckets.delete(hash2);
+  }
+  return self;
+});
+var size = (self) => self.backing.size;
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Cache.js
+var TypeId2 = "~effect/Cache";
+var makeWith = (lookup, options) => contextWith((context) => {
+  const self = Object.create(Proto);
+  self.lookup = (key) => updateContext(lookup(key), (input) => merge(context, input));
+  self.map = make();
+  self.capacity = options.capacity;
+  self.timeToLive = options.timeToLive ? (exit, key) => fromInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
+  return succeed2(self);
+});
+var Proto = {
+  ...PipeInspectableProto,
+  [TypeId2]: TypeId2,
+  toJSON() {
+    return {
+      _id: "Cache",
+      capacity: this.capacity,
+      map: this.map
+    };
+  }
+};
+var defaultTimeToLive = (_, _key) => infinity;
+var get2 = /* @__PURE__ */ dual(2, (self, key) => withFiber((fiber) => {
+  const oentry = get(self.map, key);
+  if (isSome(oentry)) {
+    remove(self.map, key);
+    if (!hasExpired(oentry.value, fiber)) {
+      set(self.map, key, oentry.value);
+      return oentry.value.await(fiber);
+    }
+  }
+  const entry = new EntryImpl(fiber, self.lookup(key));
+  entry.onInterrupt = () => removeEntry(self, key, entry);
+  let skipCache = false;
+  entry.fiber.addObserver((exit) => {
+    entry.onInterrupt = undefined;
+    if (exitHasInterrupts(exit)) {
+      removeEntry(self, key, entry);
+      return;
+    }
+    const ttl = self.timeToLive(exit, key);
+    if (isZero(ttl)) {
+      skipCache = true;
+      removeEntry(self, key, entry);
+    } else if (isFinite(ttl)) {
+      entry.expiresAt = fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl);
+    }
+  });
+  const exit = entry.fiber.pollUnsafe();
+  if (!skipCache && (exit === undefined || !exitHasInterrupts(exit))) {
+    set(self.map, key, entry);
+  }
+  if (Number.isFinite(self.capacity)) {
+    checkCapacity(self);
+  }
+  return entry.await(fiber);
+}));
+
+class EntryImpl {
+  expiresAt;
+  awaiters;
+  fiber;
+  onInterrupt;
+  constructor(parent, valueEffect) {
+    this.fiber = forkUnsafe(parent, valueEffect, true, true);
+    this.awaiters = 0;
+    this.expiresAt = undefined;
+  }
+  await(fiber) {
+    if (fiber === undefined)
+      return withFiber((fiber) => this.await(fiber));
+    const exit = this.fiber.pollUnsafe();
+    if (exit)
+      return exit;
+    this.awaiters++;
+    onExitUnsafe(fiber, () => {
+      this.awaiters--;
+      if (this.awaiters > 0 || this.fiber.pollUnsafe())
+        return void_;
+      this.onInterrupt?.();
+      return fiberInterrupt(this.fiber);
+    });
+    return fiberJoin(this.fiber);
+  }
+}
+var removeEntry = (self, key, entry) => {
+  const current = get(self.map, key);
+  if (isSome(current) && current.value === entry) {
+    remove(self.map, key);
+  }
+};
+var hasExpired = (entry, fiber) => {
+  if (entry.expiresAt === undefined) {
+    return false;
+  }
+  return fiber.getRef(ClockRef).currentTimeMillisUnsafe() >= entry.expiresAt;
+};
+var checkCapacity = (self) => {
+  let diff = size(self.map) - self.capacity;
+  if (diff <= 0)
+    return;
+  for (const [key] of self.map) {
+    remove(self.map, key);
+    diff--;
+    if (diff === 0)
+      return;
+  }
+};
+var invalidate = /* @__PURE__ */ dual(2, (self, key) => sync(() => {
+  remove(self.map, key);
+}));
+
+// dist/channel/github-app-client.js
+import { createPrivateKey, sign } from "crypto";
+var apiBase = "https://api.github.com";
+var requiredEvents = [
+  "issues",
+  "issue_comment",
+  "pull_request",
+  "pull_request_review_comment"
+];
+var App = Struct({
+  id: NumericId2,
+  slug: NonEmptyString
+});
+var AppInstallation = Struct({
+  app_id: NumericId2,
+  events: ArraySchema(String3),
+  permissions: Struct({
+    issues: optionalKey(String3),
+    pull_requests: optionalKey(String3)
+  }),
+  suspended_at: optionalKey(NullOr(String3))
+});
+var HookConfig = Struct({
+  content_type: optionalKey(String3),
+  url: optionalKey(String3)
+});
+var BotUser = Struct({
+  id: NumericId2,
+  type: Literal("Bot")
+});
+var InstallationToken = Struct({
+  expires_at: DateTimeUtcFromString,
+  token: NonEmptyString
+});
+var CollaboratorPermission = Struct({
+  permission: String3,
+  role_name: String3
+});
+var Author = NullOr(Struct({
+  id: NumericId2,
+  login: NonEmptyString
+}));
+var Comment2 = Struct({
+  body: NullOr(String3),
+  created_at: AgentChannel_exports.Timestamp,
+  id: NumericId2,
+  user: Author
+});
+var IssueRecord2 = Struct({
+  body: NullOr(String3),
+  comments: Natural,
+  created_at: AgentChannel_exports.Timestamp,
+  title: String3,
+  user: Author
+});
+var Created = Struct({ id: NumericId2 });
+var CommentOwner = Struct({
+  issue_url: String3,
+  user: Author
+});
+var JwtHeader = fromJsonString(Struct({
+  alg: Literal("RS256"),
+  typ: Literal("JWT")
+}));
+var JwtClaims = fromJsonString(Struct({
+  exp: Int,
+  iat: Int,
+  iss: String3
+}));
+var encoder = new TextEncoder;
+var pemWhitespace = /\s/gu;
+function der(tag, bytes) {
+  if (bytes.length < 128)
+    return Uint8Array.of(tag, bytes.length, ...bytes);
+  if (bytes.length < 256)
+    return Uint8Array.of(tag, 129, bytes.length, ...bytes);
+  return Uint8Array.of(tag, 130, bytes.length >> 8, bytes.length & 255, ...bytes);
+}
+function pkcs8(pem) {
+  const trimmed = trim(pem);
+  const pkcs1 = startsWith("-----BEGIN RSA PRIVATE KEY-----")(trimmed);
+  const label = pipe(value2(pkcs1), when(true, () => "RSA PRIVATE KEY"), orElse2(() => "PRIVATE KEY"));
+  if (!startsWith(`-----BEGIN ${label}-----`)(trimmed) || !endsWith(`-----END ${label}-----`)(trimmed))
+    return none();
+  const body = pipe(trimmed, replace(`-----BEGIN ${label}-----`, ""), replace(`-----END ${label}-----`, ""), replaceAll(pemWhitespace, ""));
+  return pipe(getSuccess(decode2(body)), map((bytes) => {
+    if (!pkcs1)
+      return bytes;
+    return der(48, Uint8Array.of(...[
+      2,
+      1,
+      0,
+      48,
+      13,
+      6,
+      9,
+      42,
+      134,
+      72,
+      134,
+      247
+    ], 13, 1, 1, 1, 5, 0, ...der(4, bytes)));
+  }));
+}
+function uncertain(sending) {
+  if (sending)
+    return "unknown_completion";
+  return "unavailable";
+}
+function failure(response, sending) {
+  const limited = response.headers["x-ratelimit-remaining"] === "0" || response.headers["retry-after"] !== undefined;
+  if (response.status === 429 || response.status === 403 && limited)
+    return "rate_limited";
+  if (response.status === 401 || response.status === 403)
+    return "unauthorized";
+  if (response.status >= 500)
+    return uncertain(sending);
+  return "rejected";
+}
+var read = fnUntraced(function* (schema, response, sending = false) {
+  if (response.status < 200 || response.status >= 300)
+    return yield* AgentChannel_exports.HandlerError.make({ code: failure(response, sending) });
+  return yield* pipe(schemaBodyJson(schema)(response), timeout("20 seconds"), mapError2(() => AgentChannel_exports.HandlerError.make({ code: uncertain(sending) })));
+});
+function readFound(schema, response) {
+  if (response.status === 404)
+    return succeed5(none());
+  return asSome(read(schema, response));
+}
+function gone(response) {
+  if (response.status === 204 || response.status === 404)
+    return void_3;
+  return fail5(AgentChannel_exports.HandlerError.make({ code: failure(response, false) }));
+}
+function repositoryPath(repository) {
+  return `/repos/${encodeURIComponent(repository.owner)}/${encodeURIComponent(repository.name)}`;
+}
+function issuePath(issue) {
+  return `${repositoryPath(issue)}/issues/${issue.number}`;
+}
+function commentPath(repository, id) {
+  return `${repositoryPath(repository)}/issues/comments/${id}`;
+}
+var GitHubAppClient2 = class GitHubAppClient extends Service()("@dual-os/github-app/github-app-client/GitHubAppClient") {
+  static layer = effect(this, gen(function* () {
+    const http = yield* HttpClient;
+    const github = pipe(http, mapRequest((request) => pipe(request, prependUrl(apiBase), setHeaders({
+      accept: "application/vnd.github+json",
+      "user-agent": "dual-github-app",
+      "x-github-api-version": apiVersion2
+    }))));
+    const send = fn("GitHubAppClient.send")(function* (request, token, sending) {
+      return yield* pipe(github.execute(bearerToken(request, token)), provideService(RequestInit, { redirect: "manual" }), timeout("20 seconds"), mapError2(() => AgentChannel_exports.HandlerError.make({ code: uncertain(sending) })));
+    });
+    const appJwt = fn("GitHubAppClient.appJwt")(function* (auth) {
+      const now = Math.floor((yield* currentTimeMillis) / 1000);
+      const unsigned = `${encode3(yield* encodeEffect(JwtHeader)({
+        alg: "RS256",
+        typ: "JWT"
+      }))}.${encode3(yield* encodeEffect(JwtClaims)({
+        exp: now + 540,
+        iat: now - 60,
+        iss: auth.appId
+      }))}`;
+      const key = yield* pipe(pkcs8(auth.privateKey), fromOption2, mapError2(() => AgentChannel_exports.HandlerError.make({ code: "unauthorized" })));
+      const signature = yield* pipe(try_2(() => sign("sha256", encoder.encode(unsigned), createPrivateKey({
+        format: "der",
+        key: Buffer.from(key),
+        type: "pkcs8"
+      }))), mapError2(() => AgentChannel_exports.HandlerError.make({ code: "unauthorized" })));
+      return `${unsigned}.${encode3(new Uint8Array(signature))}`;
+    }, catchTag("SchemaError", () => AgentChannel_exports.HandlerError.make({ code: "unauthorized" })));
+    const appGet = fn("GitHubAppClient.appGet")(function* (auth, path, schema) {
+      return yield* read(schema, yield* send(get3(path), yield* appJwt(auth), false));
+    });
+    const tokens = yield* makeWith((installation) => gen(function* () {
+      const response = yield* send(post(`/app/installations/${installation.installationId}/access_tokens`), yield* appJwt(installation.auth), false);
+      const created = yield* read(InstallationToken, response);
+      const ttl = toEpochMillis(created.expires_at) - (yield* currentTimeMillis) - 60000;
+      if (ttl <= 0)
+        return yield* AgentChannel_exports.HandlerError.make({ code: "unavailable" });
+      return {
+        token: created.token,
+        ttl: min(ttl, 3540000)
+      };
+    }), {
+      capacity: 1000,
+      timeToLive: (exit) => {
+        if (isSuccess2(exit))
+          return millis(exit.value.ttl);
+        return zero;
+      }
+    });
+    const call = fn("GitHubAppClient.call")(function* (installation, request, sending = false) {
+      const minted = yield* get2(tokens, installation);
+      const response = yield* send(request, minted.token, sending);
+      if (response.status === 401)
+        yield* invalidate(tokens, installation);
+      return response;
+    });
+    const checkInstallation = fn("GitHubAppClient.checkInstallation")(function* (installation) {
+      const app = yield* appGet(installation.auth, "/app", App);
+      const found = yield* appGet(installation.auth, `/app/installations/${installation.installationId}`, AppInstallation);
+      if (`${app.id}` !== installation.auth.appId || found.app_id !== app.id)
+        return yield* AgentChannel_exports.HandlerError.make({ code: "unauthorized" });
+      if (found.suspended_at !== undefined && found.suspended_at !== null || found.permissions.issues !== "write" || found.permissions.pull_requests !== "write" || !every(requiredEvents, (event) => contains(found.events, event)))
+        return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+      return {
+        botUserId: `${(yield* read(BotUser, yield* call(installation, get3(`/users/${encodeURIComponent(`${app.slug}[bot]`)}`)))).id}`,
+        slug: app.slug
+      };
+    });
+    const registerWebhook = fn("GitHubAppClient.registerWebhook")(function* (auth, ingressUrl) {
+      const hook = yield* read(HookConfig, yield* send(bodyJsonUnsafe(patch("/app/hook/config"), {
+        content_type: "json",
+        insecure_ssl: "0",
+        secret: auth.webhookSecret,
+        url: ingressUrl
+      }), yield* appJwt(auth), false));
+      if (hook.url !== ingressUrl || hook.content_type !== "json")
+        return yield* AgentChannel_exports.HandlerError.make({ code: "rejected" });
+    });
+    const permission = fn("GitHubAppClient.permission")(function* (installation, repository, login) {
+      const found = yield* readFound(CollaboratorPermission, yield* call(installation, get3(`${repositoryPath(repository)}/collaborators/${encodeURIComponent(login)}/permission`)));
+      return pipe(found, flatMap((role) => pipe(decodeUnknownOption(Permission2)(role.role_name), orElse(() => decodeUnknownOption(Permission2)(role.permission)))), getOrElse(() => "none"));
+    });
+    const postComment = fn("GitHubAppClient.postComment")(function* (installation, issue, text) {
+      const response = yield* call(installation, bodyJsonUnsafe(post(`${issuePath(issue)}/comments`), { body: text }), true);
+      return `${(yield* read(Created, response, true)).id}`;
+    });
+    const checkOwnComment = fn("GitHubAppClient.checkOwnComment")(function* (installation, issue, id, botUserId) {
+      const found = yield* readFound(CommentOwner, yield* call(installation, get3(commentPath(issue, id))));
+      return yield* match2(found, {
+        onNone: () => succeed5(false),
+        onSome: (comment) => {
+          if (comment.user === null || `${comment.user.id}` !== botUserId || comment.issue_url !== `${apiBase}${issuePath(issue)}`)
+            return fail5(AgentChannel_exports.HandlerError.make({ code: "rejected" }));
+          return succeed5(true);
+        }
+      });
+    });
+    const editComment = fn("GitHubAppClient.editComment")(function* (installation, repository, id, text) {
+      const response = yield* call(installation, bodyJsonUnsafe(patch(commentPath(repository, id)), { body: text }));
+      return isSome(yield* readFound(Created, response));
+    });
+    const deleteComment = fn("GitHubAppClient.deleteComment")(function* (installation, repository, id) {
+      yield* gone(yield* call(installation, del(commentPath(repository, id))));
+    });
+    const react = fn("GitHubAppClient.react")(function* (installation, issue, target, content, active) {
+      const path = pipe(value2(target), when({ kind: "issue" }, () => `${issuePath(issue)}/reactions`), when({ kind: "comment" }, (comment) => `${commentPath(issue, comment.id)}/reactions`), when({ kind: "review-comment" }, (comment) => `${repositoryPath(issue)}/pulls/comments/${comment.id}/reactions`), exhaustive);
+      const response = yield* call(installation, bodyJsonUnsafe(post(path), { content }));
+      if (active) {
+        yield* read(Created, response);
+        return;
+      }
+      yield* match2(yield* readFound(Created, response), {
+        onNone: () => void_3,
+        onSome: (reaction) => flatMap3(call(installation, del(`${path}/${reaction.id}`)), gone)
+      });
+    });
+    const readComments = fn("GitHubAppClient.readComments")(function* (installation, issue, limit) {
+      const record = yield* read(IssueRecord2, yield* call(installation, get3(issuePath(issue))));
+      const last = Math.ceil(record.comments / 100);
+      const pages = filter2([
+        last - 2,
+        last - 1,
+        last
+      ], (number) => number >= 1 && (last - number) * 100 < limit + 100);
+      const comments = yield* forEach(pages, (number) => flatMap3(call(installation, setUrlParams(get3(`${issuePath(issue)}/comments`), {
+        page: `${number}`,
+        per_page: "100"
+      })), (response) => read(ArraySchema(Comment2), response)), { concurrency: 1 });
+      return {
+        comments: takeRight(flatten(comments), limit),
+        issue: record
+      };
+    });
+    return GitHubAppClient.of({
+      checkInstallation,
+      checkOwnComment,
+      deleteComment,
+      editComment,
+      permission,
+      postComment,
+      react,
+      readComments,
+      registerWebhook
+    });
+  }));
+};
+export { Comment2, IssueRecord2, GitHubAppClient2 };
+
+//# debugId=647D02E757151B0164756E2164756E21
+//# sourceMappingURL=plugin-p6f7n836.js.map