@certik/skynet 0.22.1 → 0.22.3

package/dist/log.d.ts

@@ -11,4 +11,3 @@ declare const logger: {
     error: (...args: unknown[]) => void;
 };
 export { print, getLine, inline, logger };
-//# sourceMappingURL=log.d.ts.map

package/dist/log.js

@@ -1,62 +1,63 @@
+// src/log.ts
 function isObject(a) {
-    return !!a && a.constructor === Object;
+  return !!a && a.constructor === Object;
 }
 function print(o) {
-    if (Array.isArray(o)) {
-        return `[${o.map(print).join(", ")}]`;
-    }
-    if (isObject(o)) {
-        return `{${Object.keys(o)
-            .map((k) => `${k}: ${o[k]}`)
-            .join(", ")}}`;
-    }
-    return `${o}`;
+  if (Array.isArray(o)) {
+    return `[${o.map(print).join(", ")}]`;
+  }
+  if (isObject(o)) {
+    return `{${Object.keys(o).map((k) => `${k}: ${o[k]}`).join(", ")}}`;
+  }
+  return `${o}`;
 }
 function getLine(params) {
-    let line = "";
-    // Convert to string and filter out newline to tabs (AWS Athena)
-    for (let i = 0, l = params.length; i < l; i++) {
-        // Certain objects don't get converted
-        // Note using JSON.stringfy may be too slow for large objects
-        line += `${print(params[i])} `.replace(/\n/gm, "\t");
-    }
-    return line.trim();
+  let line = "";
+  for (let i = 0, l = params.length;i < l; i++) {
+    line += `${print(params[i])} `.replace(/\n/gm, "\t");
+  }
+  return line.trim();
 }
 function timestamp() {
-    return new Date().toISOString();
+  return new Date().toISOString();
 }
-const inline = {
-    debug: function (...args) {
-        if (process.env.NODE_ENV === "development") {
-            console.log(`${timestamp()} ${getLine(args)}`);
-        }
-    },
-    log: function (...args) {
-        if (process.env.NODE_ENV !== "test") {
-            console.log(`${timestamp()} ${getLine(args)}`);
-        }
-    },
-    error: function (...args) {
-        if (process.env.NODE_ENV !== "test") {
-            console.error(`${timestamp()} ${getLine(args)}`);
-        }
-    },
+var inline = {
+  debug: function(...args) {
+    if (true) {
+      console.log(`${timestamp()} ${getLine(args)}`);
+    }
+  },
+  log: function(...args) {
+    if (true) {
+      console.log(`${timestamp()} ${getLine(args)}`);
+    }
+  },
+  error: function(...args) {
+    if (true) {
+      console.error(`${timestamp()} ${getLine(args)}`);
+    }
+  }
+};
+var logger = {
+  debug: function(...args) {
+    if (true) {
+      console.log(`[${timestamp()}]`, ...args);
+    }
+  },
+  log: function(...args) {
+    if (true) {
+      console.log(`[${timestamp()}]`, ...args);
+    }
+  },
+  error: function(...args) {
+    if (true) {
+      console.error(`[${timestamp()}]`, ...args);
+    }
+  }
 };
-const logger = {
-    debug: function (...args) {
-        if (process.env.NODE_ENV === "development") {
-            console.log(`[${timestamp()}]`, ...args);
-        }
-    },
-    log: function (...args) {
-        if (process.env.NODE_ENV !== "test") {
-            console.log(`[${timestamp()}]`, ...args);
-        }
-    },
-    error: function (...args) {
-        if (process.env.NODE_ENV !== "test") {
-            console.error(`[${timestamp()}]`, ...args);
-        }
-    },
+export {
+  print,
+  logger,
+  inline,
+  getLine
 };
-export { print, getLine, inline, logger };

package/dist/object-hash.d.ts

@@ -1,2 +1 @@
 export declare function getHash(obj: unknown): string;
-//# sourceMappingURL=object-hash.d.ts.map

package/dist/object-hash.js

@@ -1,71 +1,61 @@
+// src/object-hash.ts
 import xh from "@node-rs/xxhash";
-export function getHash(obj) {
-    const xxh3 = xh.xxh3.Xxh3.withSeed();
-    hash(obj, xxh3);
-    return xxh3.digest().toString(16);
+function getHash(obj) {
+  const xxh3 = xh.xxh3.Xxh3.withSeed();
+  hash(obj, xxh3);
+  return xxh3.digest().toString(16);
 }
 function hash(obj, xxh3) {
-    if (obj === null) {
-        xxh3.update("null");
-    }
-    else if (obj === undefined) {
-        xxh3.update("undefined");
-    }
-    else if (typeof obj === "string") {
-        xxh3.update(obj);
-    }
-    else if (typeof obj === "number") {
-        xxh3.update(obj.toString());
-    }
-    else if (typeof obj === "boolean") {
-        xxh3.update(obj.toString());
-    }
-    else if (typeof obj === "bigint") {
-        xxh3.update(obj.toString());
-    }
-    else if (obj instanceof Date) {
-        xxh3.update(obj.toISOString());
-    }
-    else if (Array.isArray(obj)) {
-        arrayHash(obj, xxh3);
-    }
-    else if (obj instanceof Set) {
-        setHash(obj, xxh3);
-    }
-    else if (obj instanceof Map) {
-        mapHash(obj, xxh3);
-    }
-    else if (typeof obj === "object") {
-        objectHash(obj, xxh3);
-    }
-    else {
-        throw new Error(`Unsupported type: ${obj}`);
-    }
+  if (obj === null) {
+    xxh3.update("null");
+  } else if (obj === undefined) {
+    xxh3.update("undefined");
+  } else if (typeof obj === "string") {
+    xxh3.update(obj);
+  } else if (typeof obj === "number") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "boolean") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "bigint") {
+    xxh3.update(obj.toString());
+  } else if (obj instanceof Date) {
+    xxh3.update(obj.toISOString());
+  } else if (Array.isArray(obj)) {
+    arrayHash(obj, xxh3);
+  } else if (obj instanceof Set) {
+    setHash(obj, xxh3);
+  } else if (obj instanceof Map) {
+    mapHash(obj, xxh3);
+  } else if (typeof obj === "object") {
+    objectHash(obj, xxh3);
+  } else {
+    throw new Error(`Unsupported type: ${obj}`);
+  }
 }
 function arrayHash(array, xxh3) {
-    xxh3.update("[");
-    for (const obj of array) {
-        hash(obj, xxh3);
-    }
-    xxh3.update("]");
+  xxh3.update("[");
+  for (const obj of array) {
+    hash(obj, xxh3);
+  }
+  xxh3.update("]");
 }
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function setHash(_set, _xxh3) {
-    throw new Error("Set hashing not implemented");
+  throw new Error("Set hashing not implemented");
 }
 function mapHash(map, xxh3) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-    for (const [key, value] of array) {
-        hash(key, xxh3);
-        hash(value, xxh3);
-    }
+  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function objectHash(obj, xxh3) {
-    const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-    for (const [key, value] of array) {
-        hash(key, xxh3);
-        hash(value, xxh3);
-    }
+  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
 }
+export {
+  getHash
+};

package/dist/opsgenie.d.ts

@@ -1,21 +1,99 @@
-type OpsgenieResponse = {
-    data: {
-        success: boolean;
-        action: string;
-        processedAt: string;
-        integrationId: string;
-        isSuccess: boolean;
-        status: string;
-        alertId: string;
-        alias: string;
-    };
-    took: number;
-    requestId: string;
-};
-export declare function postGenieMessage(body: {
-    alias?: string;
+export type OpsgeniePriority = "P1" | "P2" | "P3" | "P4" | "P5";
+export interface TeamRefById {
+    id: string;
+    type: "team";
+}
+export interface TeamRefByName {
+    name: string;
+    type: "team";
+}
+export type TeamRef = TeamRefById | TeamRefByName;
+export interface UserRefById {
+    id: string;
+    type: "user";
+}
+export interface UserRefByUsername {
+    username: string;
+    type: "user";
+}
+export type UserRef = UserRefById | UserRefByUsername;
+export interface EscalationRefById {
+    id: string;
+    type: "escalation";
+}
+export interface EscalationRefByName {
+    name: string;
+    type: "escalation";
+}
+export type EscalationRef = EscalationRefById | EscalationRefByName;
+export interface ScheduleRefById {
+    id: string;
+    type: "schedule";
+}
+export interface ScheduleRefByName {
+    name: string;
+    type: "schedule";
+}
+export type ScheduleRef = ScheduleRefById | ScheduleRefByName;
+export type ResponderRef = TeamRef | UserRef | EscalationRef | ScheduleRef;
+export interface VisibleToTeamById {
+    id: string;
+    type: "team";
+}
+export interface VisibleToTeamByName {
+    name: string;
+    type: "team";
+}
+export type VisibleToTeam = VisibleToTeamById | VisibleToTeamByName;
+export interface VisibleToUserById {
+    id: string;
+    type: "user";
+}
+export interface VisibleToUserByUsername {
+    username: string;
+    type: "user";
+}
+export type VisibleToUser = VisibleToUserById | VisibleToUserByUsername;
+export type VisibleToRef = VisibleToTeam | VisibleToUser;
+export interface CreateAlertRequest {
     message: string;
+    alias?: string;
     description?: string;
-}, apiKey?: string, verbose?: boolean): Promise<OpsgenieResponse>;
-export {};
-//# sourceMappingURL=opsgenie.d.ts.map
+    responders?: ResponderRef[];
+    visibleTo?: VisibleToRef[];
+    actions?: string[];
+    tags?: string[];
+    details?: Record<string, string>;
+    entity?: string;
+    source?: string;
+    priority?: OpsgeniePriority;
+    user?: string;
+    note?: string;
+}
+export interface OpsgenieAcceptedResponse {
+    result: string;
+    took: number;
+    requestId: string;
+}
+export interface OpsgenieRequestStatusData {
+    success: boolean;
+    action: string;
+    processedAt: string;
+    integrationId: string;
+    isSuccess: boolean;
+    status: string;
+    alertId: string;
+    alias: string;
+}
+export interface OpsgenieRequestStatusResponse extends OpsgenieAcceptedResponse {
+    data: OpsgenieRequestStatusData;
+}
+export type OpsgenieResponse = OpsgenieAcceptedResponse | OpsgenieRequestStatusResponse;
+export interface OpsgenieErrorResponse {
+    message?: string;
+    took?: number;
+    requestId?: string;
+    errors?: unknown;
+    status?: number | string;
+}
+export declare function postGenieMessage(body: CreateAlertRequest, apiKey?: string, verbose?: boolean): Promise<OpsgenieResponse>;

package/dist/opsgenie.js

@@ -1,38 +1,43 @@
+// src/opsgenie.ts
 import md5 from "md5";
 function getGenieKey(key) {
-    return key || process.env["SKYNET_OPSGENIE_API_KEY"];
+  return key || process.env["SKYNET_OPSGENIE_API_KEY"];
 }
 function getGenieEndPoint() {
-    return process.env["SKYNET_OPSGENIE_END_POINT"] || "https://api.opsgenie.com/v2/alerts";
+  return process.env["SKYNET_OPSGENIE_END_POINT"] || "https://api.opsgenie.com/v2/alerts";
 }
-export async function postGenieMessage(body, apiKey, verbose) {
-    try {
-        const genieKey = apiKey || getGenieKey();
-        const genieEndPoint = getGenieEndPoint();
-        // Prevents duplicate alerts (See Opsgenie doc about alias)
-        if (!body.alias) {
-            body.alias = md5(body.message);
-        }
-        if (verbose) {
-            console.log(`Making API call to Opsgenie`, JSON.stringify(body, null, 2));
-        }
-        // Makes the call using fetch and ENV variables
-        const response = await fetch(genieEndPoint, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `GenieKey ${genieKey}`,
-            },
-            body: JSON.stringify(body),
-        });
-        const result = await response.json();
-        if (verbose) {
-            console.log(`Result of API call to Opsgenie... ${result}`);
-        }
-        return result;
+async function postGenieMessage(body, apiKey, verbose) {
+  try {
+    const genieKey = apiKey || getGenieKey();
+    const genieEndPoint = getGenieEndPoint();
+    if (!body.alias) {
+      body.alias = md5(body.message);
     }
-    catch (error) {
-        console.error("Failed to make opsgenie API call", error);
-        throw error;
+    if (verbose) {
+      console.log(`Making API call to Opsgenie`, JSON.stringify(body, null, 2));
     }
+    const response = await fetch(genieEndPoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `GenieKey ${genieKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    const json = await response.json();
+    if (verbose) {
+      console.log("Result of API call to Opsgenie...", json);
+    }
+    if ("result" in json) {
+      return json;
+    }
+    console.error("Error response from Opsgenie API", json);
+    throw new Error(json.message || "Unknown error from Opsgenie API");
+  } catch (error) {
+    console.error("Failed to make opsgenie API call", error);
+    throw error;
+  }
 }
+export {
+  postGenieMessage
+};

package/dist/por.d.ts

@@ -35,4 +35,3 @@ export declare class MerkleTreePoR {
     generateProof(userHash: string, token?: string): MerkleProof;
     static verifyProof(merkleProof: MerkleProof): boolean;
 }
-//# sourceMappingURL=por.d.ts.map