@sailfish-ai/sf-veritas 0.1.21 → 0.1.23

package/dist/types/constants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Error message used when there is a failure in retrieving request source code.
+ */
+export declare const REQUEST_SOURCE_CODE_ERROR = "getting request source code";
+/**
+ * Common constant values used across the application.
+ */
+export declare enum Constants {
+    /**
+     * Represents an unknown value or state.
+     */
+    UNKNOWN = "unknown",
+    /**
+     * Represents an anonymous user or entity.
+     */
+    ANONYMOUS = "anonymous",
+    /**
+     * Represents data that was not captured or is unavailable.
+     */
+    NOT_CAPTURED = "not captured"
+}
+/**
+ * The default number of stack frames to capture, typically for logging or error reporting.
+ */
+export declare const COUNT_OF_FRAMES_TO_BE_CAPTURED = 10;
+/**
+ * Default protocol used when a secure connection is not required.
+ */
+export declare const DEFAULT_PROTOCOL = "http:";
+/**
+ * Default protocol used when a secure (HTTPS) connection is required.
+ */
+export declare const DEFAULT_SECURE_PROTOCOL = "https:";

package/dist/types/debuggerWorker.d.ts

@@ -1 +1,9 @@
-export {};
+/**
+ * Processes call frames from an exception and posts them via the Worker’s parentPort.
+ *
+ * @param session - The DevTools session or similar object you use to query for script sources.
+ * @param callFrames - An array of call frame objects.
+ * @param descriptionLines - An array of lines from the error’s description, each typically beginning with "at ".
+ * @returns {Promise<void>}
+ */
+export declare function processCallFrames(session: any, callFrames: any, descriptionLines: any): Promise<void>;

package/dist/types/generated/worker-data.d.ts

@@ -1 +1 @@
-export declare const fileContentsEncoded = "import { Session } from "inspector/promises";
import { parentPort, workerData } from "worker_threads";

global.sfDebug = undefined;
global.stackDepthLocals = undefined;
global.errorId = undefined;
global.nodeModulesToCollectLocalVariablesOn = undefined;

/**
 * Handles the "paused" state of the debugger and processes exceptions or promise rejections.
 * @param {Session} session - The debugging session instance.
 * @param {object} params - Parameters from the "paused" event.
 */
async function handlePaused(session, params) {
  const { reason, data, callFrames } = params;

  if (reason !== "exception" && reason !== "promiseRejection") {
    await session.post("Debugger.resume");
    return;
  }

  const errorId = global?.errorId;

  const limitedCallFrames = callFrames;

  const frames = await Promise.all(
    limitedCallFrames.map(async (frame) => {
      try {
        const { functionName, location, url, scopeChain } = frame;
        const localScope = scopeChain.find((scope) => scope.type === "local");

        let code = "<not captured>";
        let file = url || "<unknown>";
        if (location && location.scriptId) {
          const scriptId = location.scriptId;
          try {
            const { scriptSource } = await session.post(
              "Debugger.getScriptSource",
              { scriptId },
            );
            const sourceLines = scriptSource.split("\n");
            code = sourceLines[location.lineNumber] || "<not captured>";
          } catch (err) {
            if (global.sfDebug) {
              console.error("[Worker] Failed to fetch script source:", err);
            }
          }
        }

        const locals = localScope?.object?.objectId
          ? await fetchLocalVariables(session, localScope.object.objectId)
          : {};

        return {
          function: functionName || "<anonymous>",
          locals,
          file,
          line: location?.lineNumber || 0,
          code,
        };
      } catch (error) {
        if (global.sfDebug) {
          console.error("[Worker] Error processing call frame:", error);
        }
        return {
          function: "<error>",
          locals: {},
          file: "<unknown>",
          line: 0,
          code: "<not captured>",
        };
      }
    }),
  );

  // Post exception data along with the errorId
  parentPort?.postMessage({ type: "exception", errorId, frames });
}

/**
 * Initializes the debugger and sets up event listeners for exceptions and promise rejections.
 */
async function startDebugger() {
  parentPort?.postMessage({ type: "message", readyToGetParameters: true });

  let resolveMessagePromise;
  const messagePromise = new Promise((resolve) => {
    resolveMessagePromise = resolve;
  });
  let isPaused = false;

  parentPort?.on("message", (message) => {
    try {
      if (message?.type === "processException") {
        return;
      }

      if (
        message?.sfDebug !== undefined &&
        message?.stackDepthLocals !== undefined
      ) {
        if (global.sfDebug) {
          console.log("Updating global debug variables...");
        }

        global.sfDebug = message.sfDebug;
        global.stackDepthLocals = message.stackDepthLocals;
        global.nodeModulesToCollectLocalVariablesOn =
          message.nodeModulesToCollectLocalVariablesOn;

        resolveMessagePromise();
      }
    } catch (error) {
      if (global.sfDebug) {
        console.error("❌ Error in message handling:", error);
      }
    }
  });

  await messagePromise;

  try {
    const session = new Session();
    session.connectToMainThread();

    session.on("Debugger.resumed", () => {
      isPaused = false;
    });

    session.on("Debugger.paused", async (event) => {
      isPaused = true;
      handlePaused(session, event.params).then(
        async () => {
          // After the pause work is complete, resume execution!
          if (isPaused) {
            await session.post("Debugger.resume");
          }
        },
        async (_) => {
          if (isPaused) {
            await session.post("Debugger.resume");
          }
        },
      );
    });

    await session.post("Debugger.enable");

    const captureAll = workerData.captureAllExceptions !== false;
    await session.post("Debugger.setPauseOnExceptions", {
      state: captureAll ? "all" : "uncaught",
    });
  } catch (error) {
    if (global.sfDebug) {
      console.error("[Worker] error ", error);
    }
  }

  if (global.sfDebug) {
    console.log("[Worker] Debugger started successfully.");
  }
}

async function unrollObject(session, objectId, name, vars) {
  const properties = await session.post("Runtime.getProperties", {
    objectId,
    ownProperties: true,
  });

  vars[name] = properties.result
    .map((v) => [v.name, v.value?.value])
    .reduce((obj, [key, val]) => {
      obj[key] = val;
      return obj;
    }, {});
}

async function unrollArray(session, objectId, name, vars) {
  const properties = await session.post("Runtime.getProperties", {
    objectId: objectId,
    ownProperties: true,
  });
  vars[name] = properties.result
    .filter((v) => v.name !== "length" && !isNaN(parseInt(v.name, 10)))
    .sort((a, b) => parseInt(a.name, 10) - parseInt(b.name, 10))
    .map((v) => v.value?.value);
}

function unrollOther(prop, vars) {
  if (!prop.value) {
    return;
  }

  if ("value" in prop.value) {
    if (prop.value.value === undefined || prop.value.value === null) {
      vars[prop.name] = `<${prop.value.value}>`;
      return;
    }

    vars[prop.name] = prop.value.value;
    return;
  }

  if ("description" in prop.value && prop.value.type !== "function") {
    vars[prop.name] = `<${prop.value.description}>`;
    return;
  }

  if (prop.value.type === "undefined") {
    vars[prop.name] = "<undefined>";
    return;
  }
}

/**
 * Fetches local variables from the given object ID.
 * @param {Session} session - The debugging session instance.
 * @param {string} objectId - The object ID representing the local scope.
 * @returns {object} A key-value map of local variable names and their values.
 */
async function fetchLocalVariables(session, objectId) {
  if (!objectId) return {};

  try {
    const { result } = await session.post("Runtime.getProperties", {
      objectId,
      ownProperties: true,
    });

    const properties = result;
    if (properties) {
      const variables = {};
      for (const prop of properties) {
        if (prop?.value?.objectId && prop?.value.className === "Array") {
          const id = prop.value.objectId;
          await unrollArray(session, id, prop.name, variables);
        } else if (
          prop?.value?.objectId &&
          prop?.value?.className === "Object"
        ) {
          const id = prop.value.objectId;
          await unrollObject(session, id, prop.name, variables);
        } else if (prop?.value) {
          unrollOther(prop, variables);
        }
      }
      return variables;
    }
  } catch (err) {
    if (global.sfDebug) {
      console.error("[Worker] Failed to fetch local variables:", err);
    }
    return {};
  }
}

startDebugger().catch((error) => {
  if (global.sfDebug) {
    console.error("[Worker] Failed to start debugger:", error);
  }
});

// Keep the worker alive
setInterval(() => {}, 10000);
";
+export declare const fileContentsEncoded = "import { Session } from "inspector/promises";
import { parentPort, workerData } from "worker_threads";

global.sfDebug = undefined;
global.stackDepthLocals = undefined;
global.nodeModulesToCollectLocalVariablesOn = undefined;

/**
 * Processes call frames from an exception and posts them via the Worker’s parentPort.
 *
 * @param session - The DevTools session or similar object you use to query for script sources.
 * @param callFrames - An array of call frame objects.
 * @param descriptionLines - An array of lines from the error’s description, each typically beginning with "at ".
 * @returns {Promise<void>}
 */
export async function processCallFrames(session, callFrames, descriptionLines) {
  /**
   * Limit the call frames to the maximum depth specified by global.stackDepthLocals.
   * This assumes that global.stackDepthLocals is defined as a number.
   */
  const limitedCallFrames = callFrames.slice(0, global.stackDepthLocals);

  const frames = await Promise.all(
    limitedCallFrames.map(async (frame, index) => {
      try {
        const { functionName, location, url, scopeChain } = frame;
        // Find the local scope, if any
        const localScope = scopeChain.find((scope) => scope.type === "local");

        let code = "<not captured>";
        // Use either the URL or the description line for file reference
        let file = "";
        if (url && url.trim() !== "") {
          file = url;
        } else if (descriptionLines[index]) {
          file = descriptionLines[index].trim();
        } else {
          file = "<unknown>";
        }

        // If we have a valid location and scriptId, fetch the code line
        if (location && location.scriptId) {
          const scriptId = location.scriptId;
          try {
            const { scriptSource } = await session.post(
              "Debugger.getScriptSource",
              {
                scriptId,
              },
            );
            const sourceLines = scriptSource.split("\n");
            code = sourceLines[location.lineNumber] || "<not captured>";
          } catch (err) {
            if (global.sfDebug) {
              console.error("[Worker] Failed to fetch script source:", err);
            }
          }
        }

        // Fetch local variables if there's an objectId
        const locals = localScope?.object?.objectId
          ? await fetchLocalVariables(session, localScope.object.objectId)
          : {};

        return {
          function: functionName || "<anonymous>",
          locals,
          file,
          line: location?.lineNumber || 0,
          code,
        };
      } catch (error) {
        if (global.sfDebug) {
          console.error("[Worker] Error processing call frame:", error);
        }
        return {
          function: "<error>",
          locals: {},
          file: "<unknown>",
          line: 0,
          code: "<not captured>",
        };
      }
    }),
  );
  // Post exception data
  parentPort?.postMessage({ type: "exception", frames });
}

/**
 * Handles the "paused" state of the debugger and processes exceptions or promise rejections.
 * @param {Session} session - The debugging session instance.
 * @param {object} params - Parameters from the "paused" event.
 */
async function handlePaused(session, params) {
  const { reason, data, callFrames } = params;

  if (reason !== "exception" && reason !== "promiseRejection") {
    return;
  }

  // Define regex patterns to identify non-application source errors.
  const nonAppPatterns = [
    /node:internal/,
    /internal\//,
    /node_modules/,
    /node:fs/,
  ];

  let firstFrameLine = "";
  let descriptionLines = [];

  if (data && typeof data.description === "string") {
    // Split the description into lines and filter to keep only lines that start with "at "
    descriptionLines = data.description
      .split("\n")
      .filter((line) => line.trim().startsWith("at "));

    // Use the first call frame line from the description for filtering.
    firstFrameLine = descriptionLines[0] || "";
    if (!firstFrameLine) {
      // If, for some reason, there's no frame, bail out
      return;
    }

    // Check if this is a "non-app" error
    const errorFromNonApp = nonAppPatterns.some((pattern) =>
      pattern.test(firstFrameLine.trim()),
    );

    // Convert `global.nodeModulesToCollectLocalVariablesOn` to an array for safety
    const nodeModulesList = Array.isArray(
      global.nodeModulesToCollectLocalVariablesOn,
    )
      ? global.nodeModulesToCollectLocalVariablesOn
      : [];
    if (errorFromNonApp) {
      // If the error is from a non-app source, we have a few scenarios:
      if (nodeModulesList.includes("__all__")) {
        // If the list includes __all__, capture local variables from *all* node_modules
        if (global.sfDebug) {
          console.log(
            "[Worker] Error is from non-app source, but capturing due to __all__ rule.",
          );
        }
        // Continue (do NOT return)...
      } else if (nodeModulesList.length > 0) {
        // Check if the first frame references one of the modules we allow capturing from
        const isFromAllowedNodeModule = nodeModulesList.some((moduleName) =>
          firstFrameLine.includes(`${moduleName}`),
        );

        if (!isFromAllowedNodeModule) {
          // Not from an allowed node module => return early
          if (global.sfDebug) {
            console.log(
              "[Worker] Error appears to be triggered from non-application sources; ignoring.",
            );
          }
          return;
        }
        // Otherwise, it's from an allowed node module, so continue
      } else {
        // If the list is empty, preserve existing behavior and ignore non-application errors
        if (global.sfDebug) {
          console.log(
            "[Worker] Error appears to be triggered from non-application sources; ignoring.",
          );
        }
        return;
      }
    }

    // If we reach this point, the error is either from app code, or from a node module allowed by the list
    // => Proceed with capturing local variables, etc.
    await processCallFrames(session, callFrames, descriptionLines);
  } else {
    // If there is no data.description or it's not a string, just return
    return;
  }
}

/**
 * Initializes the debugger and sets up event listeners for exceptions and promise rejections.
 */
async function startDebugger() {
  parentPort?.postMessage({ type: "message", readyToGetParameters: true });

  let resolveMessagePromise;
  const messagePromise = new Promise((resolve) => {
    resolveMessagePromise = resolve;
  });
  let isPaused = false;

  parentPort?.on("message", (message) => {
    try {
      if (message?.type === "processException") {
        return;
      }

      if (
        message?.sfDebug !== undefined &&
        message?.stackDepthLocals !== undefined
      ) {
        if (global.sfDebug) {
          console.log("Updating global debug variables...");
        }

        global.sfDebug = message.sfDebug;
        global.stackDepthLocals = message.stackDepthLocals;
        global.nodeModulesToCollectLocalVariablesOn =
          message.nodeModulesToCollectLocalVariablesOn;

        resolveMessagePromise();
      }
    } catch (error) {
      if (global.sfDebug) {
        console.error("❌ Error in message handling:", error);
      }
    }
  });

  await messagePromise;

  try {
    const session = new Session();
    session.connectToMainThread();

    session.on("Debugger.resumed", () => {
      isPaused = false;
    });

    session.on("Debugger.paused", async (event) => {
      isPaused = true;
      handlePaused(session, event.params).then(
        async () => {
          // After the pause work is complete, resume execution!
          if (isPaused) {
            await session.post("Debugger.resume");
          }
        },
        async (_) => {
          if (isPaused) {
            await session.post("Debugger.resume");
          }
        },
      );
    });

    await session.post("Debugger.enable");

    const captureAll = workerData.captureAllExceptions !== false;
    await session.post("Debugger.setPauseOnExceptions", {
      state: captureAll ? "all" : "uncaught",
    });
  } catch (error) {
    if (global.sfDebug) {
      console.error("[Worker] error ", error);
    }
  }

  if (global.sfDebug) {
    console.log("[Worker] Debugger started successfully.");
  }
}

async function unrollObject(session, objectId, name, vars) {
  const properties = await session.post("Runtime.getProperties", {
    objectId,
    ownProperties: true,
  });

  vars[name] = properties.result
    .map((v) => [v.name, v.value?.value])
    .reduce((obj, [key, val]) => {
      obj[key] = val;
      return obj;
    }, {});
}

async function unrollArray(session, objectId, name, vars) {
  const properties = await session.post("Runtime.getProperties", {
    objectId: objectId,
    ownProperties: true,
  });
  vars[name] = properties.result
    .filter((v) => v.name !== "length" && !isNaN(parseInt(v.name, 10)))
    .sort((a, b) => parseInt(a.name, 10) - parseInt(b.name, 10))
    .map((v) => v.value?.value);
}

function unrollOther(prop, vars) {
  if (!prop.value) {
    return;
  }

  if ("value" in prop.value) {
    if (prop.value.value === undefined || prop.value.value === null) {
      vars[prop.name] = `<${prop.value.value}>`;
      return;
    }

    vars[prop.name] = prop.value.value;
    return;
  }

  if ("description" in prop.value && prop.value.type !== "function") {
    vars[prop.name] = `<${prop.value.description}>`;
    return;
  }

  if (prop.value.type === "undefined") {
    vars[prop.name] = "<undefined>";
    return;
  }
}

/**
 * Fetches local variables from the given object ID.
 * @param {Session} session - The debugging session instance.
 * @param {string} objectId - The object ID representing the local scope.
 * @returns {object} A key-value map of local variable names and their values.
 */
async function fetchLocalVariables(session, objectId) {
  if (!objectId) return {};

  try {
    const { result } = await session.post("Runtime.getProperties", {
      objectId,
      ownProperties: true,
    });

    const properties = result;
    if (properties) {
      const variables = {};
      for (const prop of properties) {
        if (prop?.value?.objectId && prop?.value.className === "Array") {
          const id = prop.value.objectId;
          await unrollArray(session, id, prop.name, variables);
        } else if (
          prop?.value?.objectId &&
          prop?.value?.className === "Object"
        ) {
          const id = prop.value.objectId;
          await unrollObject(session, id, prop.name, variables);
        } else if (prop?.value) {
          unrollOther(prop, variables);
        }
      }
      return variables;
    }
  } catch (err) {
    if (global.sfDebug) {
      console.error("[Worker] Failed to fetch local variables:", err);
    }
    return {};
  }
}

startDebugger().catch((error) => {
  if (global.sfDebug) {
    console.error("[Worker] Failed to start debugger:", error);
  }
});

// Keep the worker alive
setInterval(() => {}, 10000);
";

package/dist/types/networkHopTransmitter.d.ts

@@ -0,0 +1,67 @@
+import { BaseTransmitter } from "./baseTransmitter";
+/**
+ * NetworkHopTransmitter class extends BaseTransmitter to handle sending
+ * "network hops" data to a remote GraphQL endpoint.
+ *
+ * This class uses the "CollectNetworkHops" mutation, defined as:
+ *   collectNetworkHops(
+ *     apiKey: String!,
+ *     sessionId: String!,
+ *     timestampMs: String!,
+ *     requestDetails: String!,
+ *     entrypoint: String!,
+ *     serviceUuid: String = null
+ *   ): Boolean!
+ *
+ * Additional fields (like library, version)
+ * may be appended or merged by the base class or the server's GraphQL schema
+ * as needed.
+ */
+export declare class NetworkHopTransmitter extends BaseTransmitter {
+    private serviceIdentifier;
+    /**
+     * Constructor for NetworkHopTransmitter.
+     * Sets the GraphQL operation name to "CollectNetworkHops".
+     */
+    constructor();
+    /**
+     * Sends the application identifier to the server. In this implementation,
+     * it delegates to the ServiceIdentifier's doSend method, which may include
+     * any app-specific logic or fields needed by the server.
+     */
+    sendAppIdentifier(): Promise<void>;
+    /**
+     * A convenience method that first sends the app identifier,
+     * then sends the detailed network hops data.
+     *
+     * @param requestDetails - JSON/string describing the network request details.
+     * @param entrypoint - The route, path, or function name that initiated the request.
+     */
+    doSend(entrypoint: string, requestDetails: string): Promise<void>;
+    /**
+     * Sends the network hops data to the remote GraphQL endpoint, using a
+     * non-blocking POST request. The GraphQL mutation is "collectNetworkHops",
+     * with various input fields (like apiKey, sessionId, timestampMs) typically
+     * merged in from the base class or runtime context.
+     *
+     * @param requestDetails - JSON/string describing the network hops or request data.
+     * @param entrypoint - The entry point (route or function) where the request originated.
+     */
+    send(requestDetails: string, entrypoint: string): Promise<void>;
+    /**
+     * Constructs the GraphQL mutation query string. This includes the required
+     * fields from the signature:
+     *   collectNetworkHops(
+     *     apiKey: String!,
+     *     sessionId: String!,
+     *     timestampMs: String!,
+     *     requestDetails: String!,
+     *     entrypoint: String!,
+     *     serviceUuid: String = null
+     *   ): Boolean!
+     *
+     * Additional fields like "library", "version" are
+     * often appended to the mutation or handled by the server schema as optional.
+     */
+    protected getQuery(): string;
+}

package/dist/types/types.d.ts

@@ -10,6 +10,7 @@ export interface FrameInfoData {
         [key: string]: any;
     };
     offender?: boolean;
+    column?: number;
 }
 /**
  * Class representing detailed information about a specific frame in a code trace.
@@ -23,6 +24,7 @@ export declare class FrameInfo {
         [key: string]: any;
     };
     offender: boolean;
+    column?: number;
     /**
      * Initializes a new instance of the `FrameInfo` class with provided frame data.
      *
@@ -32,8 +34,9 @@ export declare class FrameInfo {
      * @param code - The code snippet for this frame.
      * @param locals - The local variables within the frame scope (optional).
      * @param offender - Indicates if this frame is considered an "offender" (optional).
+     * @param column - The column number of the frame (optional).
      */
-    constructor({ file, line, function: func, code, locals, offender, }: FrameInfoData);
+    constructor({ file, line, function: func, code, locals, offender, column, }: FrameInfoData);
     /**
      * Converts the `FrameInfo` instance to a dictionary format, serializing local variables as strings.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailfish-ai/sf-veritas",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "publishPublicly": true,
   "description": "A versatile Edge Runtime-compatible package for Next.js.",
   "main": "./dist/sf-veritas.cjs",
@@ -27,20 +27,21 @@
   ],
   "author": "SailfishAI",
   "dependencies": {
+    "source-map-js": "^1.2.1",
     "next": "^15.1.7",
     "uuid": "^11.1.0"
   },
   "devDependencies": {
     "@rollup/plugin-terser": "^0.4.4",
-    "@types/node": "^22.13.5",
+    "@types/node": "^22.13.10",
+    "eslint": "^9.22.0",
+    "eslint-config-next": "^15.2.3",
     "@types/uuid": "^10.0.0",
     "rollup": "^3.29.5",
     "rollup-plugin-dts": "^5.3.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.3",
-    "vite": "^6.2.0",
-    "eslint": "^9.21.0",
-    "eslint-config-next": "^15.1.7"
+    "typescript": "^5.8.2",
+    "vite": "^6.2.2"
   },
   "files": [
     "dist"