mobbdev 1.1.16 → 1.1.19

package/dist/args/commands/upload_ai_blame.mjs

@@ -1118,6 +1118,31 @@ var GetUserMvsAutoFixDocument = `
   }
 }
     `;
+var StreamBlameAiAnalysisRequestsDocument = `
+    subscription streamBlameAiAnalysisRequests($requestIds: [uuid!]!) {
+  blame_ai_analysis_request(where: {id: {_in: $requestIds}}) {
+    id
+    state
+    commitId
+    organizationId
+    createdOn
+  }
+}
+    `;
+var StreamCommitBlameRequestsDocument = `
+    subscription streamCommitBlameRequests($requestIds: [uuid!]!) {
+  commit_blame_request(where: {id: {_in: $requestIds}}) {
+    id
+    state
+    organizationId
+    repositoryUrl
+    commitSha
+    createdOn
+    completedOn
+    error
+  }
+}
+    `;
 var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
 function getSdk(client, withWrapper = defaultWrapper) {
   return {
@@ -1216,6 +1241,12 @@ function getSdk(client, withWrapper = defaultWrapper) {
     },
     GetUserMvsAutoFix(variables, requestHeaders, signal) {
       return withWrapper((wrappedRequestHeaders) => client.request({ document: GetUserMvsAutoFixDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetUserMvsAutoFix", "query", variables);
+    },
+    streamBlameAiAnalysisRequests(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: StreamBlameAiAnalysisRequestsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "streamBlameAiAnalysisRequests", "subscription", variables);
+    },
+    streamCommitBlameRequests(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: StreamCommitBlameRequestsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "streamCommitBlameRequests", "subscription", variables);
     }
   };
 }
@@ -2399,75 +2430,78 @@ function createWSClient(options) {
     }
   });
 }
-function subscribe(query, variables, callback, wsClientOptions) {
-  return new Promise((resolve, reject) => {
-    let timer = null;
-    let settled = false;
-    const { timeoutInMs = SUBSCRIPTION_TIMEOUT_MS } = wsClientOptions;
-    const client = createWSClient(wsClientOptions);
-    let unsubscribe = () => {
-      return;
-    };
-    function cleanup() {
+function subscribeStream(query, variables, handlers, wsClientOptions) {
+  let timer = null;
+  const { timeoutInMs = SUBSCRIPTION_TIMEOUT_MS } = wsClientOptions;
+  const client = createWSClient(wsClientOptions);
+  let unsub = null;
+  let settled = false;
+  const cleanup = () => {
+    if (unsub) {
       try {
-        unsubscribe();
+        unsub();
       } catch {
       }
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
+      unsub = null;
     }
-    function finalizeResolve(data) {
-      if (settled) {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  const finalizeError = (error) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    cleanup();
+    handlers.error(error);
+  };
+  unsub = client.subscribe(
+    { query, variables },
+    {
+      next: (payload) => {
+        if (settled) {
+          return;
+        }
+        if (!payload.data) {
+          finalizeError(
+            new Error(
+              `Broken data object from graphQL subscribe: ${JSON.stringify(
+                payload
+              )} for query: ${query}`
+            )
+          );
+          return;
+        }
+        handlers.next(payload.data);
+      },
+      error: (error) => {
+        finalizeError(error);
+      },
+      complete: () => {
         return;
       }
-      settled = true;
-      cleanup();
-      resolve(data);
     }
-    function finalizeReject(error) {
+  );
+  if (typeof timeoutInMs === "number") {
+    timer = setTimeout(() => {
+      finalizeError(
+        new Error(
+          `Timeout expired for graphQL subscribe query: ${query} with timeout: ${timeoutInMs}`
+        )
+      );
+    }, timeoutInMs);
+  }
+  return {
+    unsubscribe: () => {
       if (settled) {
         return;
       }
       settled = true;
       cleanup();
-      reject(error);
-    }
-    unsubscribe = client.subscribe(
-      { query, variables },
-      {
-        next: (data) => {
-          if (!data.data) {
-            finalizeReject(
-              new Error(
-                `Broken data object from graphQL subscribe: ${JSON.stringify(
-                  data
-                )} for query: ${query}`
-              )
-            );
-          } else {
-            callback(finalizeResolve, finalizeReject, data.data);
-          }
-        },
-        error: (error) => {
-          finalizeReject(error);
-        },
-        complete: () => {
-          return;
-        }
-      }
-    );
-    if (typeof timeoutInMs === "number") {
-      timer = setTimeout(() => {
-        finalizeReject(
-          new Error(
-            `Timeout expired for graphQL subscribe query: ${query} with timeout: ${timeoutInMs}`
-          )
-        );
-      }, timeoutInMs);
     }
-  });
+  };
 }
 
 // src/features/analysis/scm/utils/index.ts
@@ -4956,32 +4990,47 @@ var GQLClient = class {
   }
   async subscribeToAnalysis(params) {
     const { callbackStates } = params;
-    return subscribe(
-      GetAnalysisSubscriptionDocument,
-      params.subscribeToAnalysisParams,
-      async (resolve, reject, data) => {
-        if (!data.analysis?.state || data.analysis?.state === "Failed" /* Failed */) {
-          const errorMessage = data.analysis?.failReason || `Analysis failed with id: ${data.analysis?.id}`;
-          reject(
-            new ReportDigestError(errorMessage, data.analysis?.failReason ?? "")
-          );
-          return;
-        }
-        if (callbackStates.includes(data.analysis?.state)) {
-          await params.callback(data.analysis.id);
-          resolve(data);
-        }
-      },
-      this._auth.type === "apiKey" ? {
-        apiKey: this._auth.apiKey,
-        type: "apiKey",
-        timeoutInMs: params.timeoutInMs,
-        proxyAgent: getProxyAgent(API_URL)
-      } : {
-        token: this._auth.token,
-        type: "token",
-        timeoutInMs: params.timeoutInMs,
-        proxyAgent: getProxyAgent(API_URL)
+    return new Promise(
+      (resolve, reject) => {
+        const subscription = subscribeStream(
+          GetAnalysisSubscriptionDocument,
+          params.subscribeToAnalysisParams,
+          {
+            next: async (data) => {
+              if (!data.analysis?.state || data.analysis?.state === "Failed" /* Failed */) {
+                const errorMessage = data.analysis?.failReason || `Analysis failed with id: ${data.analysis?.id}`;
+                subscription.unsubscribe();
+                reject(
+                  new ReportDigestError(
+                    errorMessage,
+                    data.analysis?.failReason ?? ""
+                  )
+                );
+                return;
+              }
+              if (callbackStates.includes(data.analysis?.state)) {
+                await params.callback(data.analysis.id);
+                subscription.unsubscribe();
+                resolve(data);
+              }
+            },
+            error: (error) => {
+              subscription.unsubscribe();
+              reject(error);
+            }
+          },
+          this._auth.type === "apiKey" ? {
+            apiKey: this._auth.apiKey,
+            type: "apiKey",
+            timeoutInMs: params.timeoutInMs,
+            proxyAgent: getProxyAgent(API_URL)
+          } : {
+            token: this._auth.token,
+            type: "token",
+            timeoutInMs: params.timeoutInMs,
+            proxyAgent: getProxyAgent(API_URL)
+          }
+        );
       }
     );
   }

package/dist/index.mjs

@@ -842,16 +842,7 @@ var init_GitService = __esm({
             this.git.revparse(["HEAD"]),
             this.git.revparse(["--abbrev-ref", "HEAD"])
           ]);
-          let normalizedRepoUrl = repoUrl.value || "";
-          if (normalizedRepoUrl.endsWith(".git")) {
-            normalizedRepoUrl = normalizedRepoUrl.slice(0, -".git".length);
-          }
-          if (normalizedRepoUrl.startsWith("git@github.com:")) {
-            normalizedRepoUrl = normalizedRepoUrl.replace(
-              "git@github.com:",
-              "https://github.com/"
-            );
-          }
+          const normalizedRepoUrl = repoUrl.value ? this.normalizeGitUrl(repoUrl.value) : "";
           this.log("[GitService] Git repository information retrieved", "debug", {
             repoUrl: normalizedRepoUrl,
             hash,
@@ -1147,6 +1138,9 @@ var init_GitService = __esm({
             }
           }
         }
+        if (normalizedUrl.startsWith("https://") || normalizedUrl.startsWith("http://")) {
+          normalizedUrl = normalizedUrl.replace(/^(https?:\/\/)([^@/]+@)/, "$1");
+        }
         return normalizedUrl;
       }
       /**
@@ -2377,6 +2371,31 @@ var GetUserMvsAutoFixDocument = `
   }
 }
     `;
+var StreamBlameAiAnalysisRequestsDocument = `
+    subscription streamBlameAiAnalysisRequests($requestIds: [uuid!]!) {
+  blame_ai_analysis_request(where: {id: {_in: $requestIds}}) {
+    id
+    state
+    commitId
+    organizationId
+    createdOn
+  }
+}
+    `;
+var StreamCommitBlameRequestsDocument = `
+    subscription streamCommitBlameRequests($requestIds: [uuid!]!) {
+  commit_blame_request(where: {id: {_in: $requestIds}}) {
+    id
+    state
+    organizationId
+    repositoryUrl
+    commitSha
+    createdOn
+    completedOn
+    error
+  }
+}
+    `;
 var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
 function getSdk(client, withWrapper = defaultWrapper) {
   return {
@@ -2475,6 +2494,12 @@ function getSdk(client, withWrapper = defaultWrapper) {
     },
     GetUserMvsAutoFix(variables, requestHeaders, signal) {
       return withWrapper((wrappedRequestHeaders) => client.request({ document: GetUserMvsAutoFixDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetUserMvsAutoFix", "query", variables);
+    },
+    streamBlameAiAnalysisRequests(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: StreamBlameAiAnalysisRequestsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "streamBlameAiAnalysisRequests", "subscription", variables);
+    },
+    streamCommitBlameRequests(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: StreamCommitBlameRequestsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "streamCommitBlameRequests", "subscription", variables);
     }
   };
 }
@@ -8463,6 +8488,16 @@ function getGithubSdk(params = {}) {
 }
 
 // src/features/analysis/scm/github/GithubSCMLib.ts
+function determinePrStatus(state, isDraft) {
+  switch (state) {
+    case "CLOSED":
+      return "CLOSED" /* Closed */;
+    case "MERGED":
+      return "MERGED" /* Merged */;
+    case "OPEN":
+      return isDraft ? "DRAFT" /* Draft */ : "ACTIVE" /* Active */;
+  }
+}
 var GithubSCMLib = class extends SCMLib {
   // we don't always need a url, what's important is that we have an access token
   constructor(url, accessToken, scmOrg) {
@@ -8910,12 +8945,7 @@ var GithubSCMLib = class extends SCMLib {
     if (!pr) {
       throw new Error(`Pull request #${prNumber} not found`);
     }
-    let prStatus = "ACTIVE" /* Active */;
-    if (pr.state === "CLOSED") {
-      prStatus = pr.mergedAt ? "MERGED" /* Merged */ : "CLOSED" /* Closed */;
-    } else if (pr.isDraft) {
-      prStatus = "DRAFT" /* Draft */;
-    }
+    const prStatus = determinePrStatus(pr.state, pr.isDraft);
     const firstCommit = pr.commits.nodes[0];
     const firstCommitDate = firstCommit ? new Date(
       firstCommit.commit.author?.date || firstCommit.commit.committedDate || pr.createdAt
@@ -10773,75 +10803,78 @@ function createWSClient(options) {
     }
   });
 }
-function subscribe(query, variables, callback, wsClientOptions) {
-  return new Promise((resolve, reject) => {
-    let timer = null;
-    let settled = false;
-    const { timeoutInMs = SUBSCRIPTION_TIMEOUT_MS } = wsClientOptions;
-    const client = createWSClient(wsClientOptions);
-    let unsubscribe = () => {
-      return;
-    };
-    function cleanup() {
+function subscribeStream(query, variables, handlers, wsClientOptions) {
+  let timer = null;
+  const { timeoutInMs = SUBSCRIPTION_TIMEOUT_MS } = wsClientOptions;
+  const client = createWSClient(wsClientOptions);
+  let unsub = null;
+  let settled = false;
+  const cleanup = () => {
+    if (unsub) {
       try {
-        unsubscribe();
+        unsub();
       } catch {
       }
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
+      unsub = null;
     }
-    function finalizeResolve(data) {
-      if (settled) {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  const finalizeError = (error) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    cleanup();
+    handlers.error(error);
+  };
+  unsub = client.subscribe(
+    { query, variables },
+    {
+      next: (payload) => {
+        if (settled) {
+          return;
+        }
+        if (!payload.data) {
+          finalizeError(
+            new Error(
+              `Broken data object from graphQL subscribe: ${JSON.stringify(
+                payload
+              )} for query: ${query}`
+            )
+          );
+          return;
+        }
+        handlers.next(payload.data);
+      },
+      error: (error) => {
+        finalizeError(error);
+      },
+      complete: () => {
         return;
       }
-      settled = true;
-      cleanup();
-      resolve(data);
     }
-    function finalizeReject(error) {
+  );
+  if (typeof timeoutInMs === "number") {
+    timer = setTimeout(() => {
+      finalizeError(
+        new Error(
+          `Timeout expired for graphQL subscribe query: ${query} with timeout: ${timeoutInMs}`
+        )
+      );
+    }, timeoutInMs);
+  }
+  return {
+    unsubscribe: () => {
       if (settled) {
         return;
       }
       settled = true;
       cleanup();
-      reject(error);
     }
-    unsubscribe = client.subscribe(
-      { query, variables },
-      {
-        next: (data) => {
-          if (!data.data) {
-            finalizeReject(
-              new Error(
-                `Broken data object from graphQL subscribe: ${JSON.stringify(
-                  data
-                )} for query: ${query}`
-              )
-            );
-          } else {
-            callback(finalizeResolve, finalizeReject, data.data);
-          }
-        },
-        error: (error) => {
-          finalizeReject(error);
-        },
-        complete: () => {
-          return;
-        }
-      }
-    );
-    if (typeof timeoutInMs === "number") {
-      timer = setTimeout(() => {
-        finalizeReject(
-          new Error(
-            `Timeout expired for graphQL subscribe query: ${query} with timeout: ${timeoutInMs}`
-          )
-        );
-      }, timeoutInMs);
-    }
-  });
+  };
 }
 
 // src/features/analysis/graphql/types.ts
@@ -11212,32 +11245,47 @@ var GQLClient = class {
   }
   async subscribeToAnalysis(params) {
     const { callbackStates } = params;
-    return subscribe(
-      GetAnalysisSubscriptionDocument,
-      params.subscribeToAnalysisParams,
-      async (resolve, reject, data) => {
-        if (!data.analysis?.state || data.analysis?.state === "Failed" /* Failed */) {
-          const errorMessage = data.analysis?.failReason || `Analysis failed with id: ${data.analysis?.id}`;
-          reject(
-            new ReportDigestError(errorMessage, data.analysis?.failReason ?? "")
-          );
-          return;
-        }
-        if (callbackStates.includes(data.analysis?.state)) {
-          await params.callback(data.analysis.id);
-          resolve(data);
-        }
-      },
-      this._auth.type === "apiKey" ? {
-        apiKey: this._auth.apiKey,
-        type: "apiKey",
-        timeoutInMs: params.timeoutInMs,
-        proxyAgent: getProxyAgent(API_URL)
-      } : {
-        token: this._auth.token,
-        type: "token",
-        timeoutInMs: params.timeoutInMs,
-        proxyAgent: getProxyAgent(API_URL)
+    return new Promise(
+      (resolve, reject) => {
+        const subscription = subscribeStream(
+          GetAnalysisSubscriptionDocument,
+          params.subscribeToAnalysisParams,
+          {
+            next: async (data) => {
+              if (!data.analysis?.state || data.analysis?.state === "Failed" /* Failed */) {
+                const errorMessage = data.analysis?.failReason || `Analysis failed with id: ${data.analysis?.id}`;
+                subscription.unsubscribe();
+                reject(
+                  new ReportDigestError(
+                    errorMessage,
+                    data.analysis?.failReason ?? ""
+                  )
+                );
+                return;
+              }
+              if (callbackStates.includes(data.analysis?.state)) {
+                await params.callback(data.analysis.id);
+                subscription.unsubscribe();
+                resolve(data);
+              }
+            },
+            error: (error) => {
+              subscription.unsubscribe();
+              reject(error);
+            }
+          },
+          this._auth.type === "apiKey" ? {
+            apiKey: this._auth.apiKey,
+            type: "apiKey",
+            timeoutInMs: params.timeoutInMs,
+            proxyAgent: getProxyAgent(API_URL)
+          } : {
+            token: this._auth.token,
+            type: "token",
+            timeoutInMs: params.timeoutInMs,
+            proxyAgent: getProxyAgent(API_URL)
+          }
+        );
       }
     );
   }
@@ -14941,54 +14989,77 @@ var McpGQLClient = class {
         params: params.subscribeToAnalysisParams
       });
       const { callbackStates } = params;
-      const result = await subscribe(
-        GetAnalysisSubscriptionDocument,
-        params.subscribeToAnalysisParams,
-        async (resolve, reject, data) => {
-          logDebug(
-            `[${scanContext}] GraphQL: GetAnalysis subscription data received ${data.analysis?.state}`,
-            { data }
-          );
-          if (!data.analysis?.state || data.analysis?.state === "Failed" /* Failed */) {
-            const errorMessage = data.analysis?.failReason || `Analysis failed with id: ${data.analysis?.id}`;
-            logError(`[${scanContext}] GraphQL: Analysis failed`, {
-              analysisId: data.analysis?.id,
-              state: data.analysis?.state,
-              failReason: data.analysis?.failReason,
-              ...this.getErrorContext()
-            });
-            reject(new Error(errorMessage));
-            return;
-          }
-          if (callbackStates.includes(data.analysis?.state)) {
-            logDebug(
-              `[${scanContext}] GraphQL: Analysis state matches callback states: ${data.analysis.state}`,
-              {
-                analysisId: data.analysis.id,
-                state: data.analysis.state,
-                callbackStates
+      return new Promise(
+        (resolve, reject) => {
+          const subscription = subscribeStream(
+            GetAnalysisSubscriptionDocument,
+            params.subscribeToAnalysisParams,
+            {
+              next: async (data) => {
+                logDebug(
+                  `[${scanContext}] GraphQL: GetAnalysis subscription data received ${data.analysis?.state}`,
+                  { data }
+                );
+                if (!data.analysis?.state || data.analysis?.state === "Failed" /* Failed */) {
+                  const errorMessage = data.analysis?.failReason || `Analysis failed with id: ${data.analysis?.id}`;
+                  logError(`[${scanContext}] GraphQL: Analysis failed`, {
+                    analysisId: data.analysis?.id,
+                    state: data.analysis?.state,
+                    failReason: data.analysis?.failReason,
+                    ...this.getErrorContext()
+                  });
+                  subscription.unsubscribe();
+                  reject(new Error(errorMessage));
+                  return;
+                }
+                if (callbackStates.includes(data.analysis?.state)) {
+                  logDebug(
+                    `[${scanContext}] GraphQL: Analysis state matches callback states: ${data.analysis.state}`,
+                    {
+                      analysisId: data.analysis.id,
+                      state: data.analysis.state,
+                      callbackStates
+                    }
+                  );
+                  await params.callback(data.analysis.id);
+                  subscription.unsubscribe();
+                  logDebug(
+                    `[${scanContext}] GraphQL: GetAnalysis subscription completed`,
+                    {
+                      analysisId: data.analysis.id,
+                      state: data.analysis.state
+                    }
+                  );
+                  resolve(data);
+                }
+              },
+              error: (error) => {
+                logError(
+                  `[${scanContext}] GraphQL: GetAnalysis subscription failed`,
+                  {
+                    error,
+                    params: params.subscribeToAnalysisParams,
+                    ...this.getErrorContext()
+                  }
+                );
+                subscription.unsubscribe();
+                reject(error);
               }
-            );
-            await params.callback(data.analysis.id);
-            resolve(data);
-          }
-        },
-        this._auth.type === "apiKey" ? {
-          apiKey: this._auth.apiKey,
-          type: "apiKey",
-          timeoutInMs: params.timeoutInMs,
-          proxyAgent: getProxyAgent2(this.apiUrl)
-        } : {
-          token: this._auth.token,
-          type: "token",
-          timeoutInMs: params.timeoutInMs,
-          proxyAgent: getProxyAgent2(this.apiUrl)
+            },
+            this._auth.type === "apiKey" ? {
+              apiKey: this._auth.apiKey,
+              type: "apiKey",
+              timeoutInMs: params.timeoutInMs,
+              proxyAgent: getProxyAgent2(this.apiUrl)
+            } : {
+              token: this._auth.token,
+              type: "token",
+              timeoutInMs: params.timeoutInMs,
+              proxyAgent: getProxyAgent2(this.apiUrl)
+            }
+          );
         }
       );
-      logDebug(`[${scanContext}] GraphQL: GetAnalysis subscription completed`, {
-        result
-      });
-      return result;
     } catch (e) {
       logError(`[${scanContext}] GraphQL: GetAnalysis subscription failed`, {
         error: e,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobbdev",
-  "version": "1.1.16",
+  "version": "1.1.19",
   "description": "Automated secure code remediation tool",
   "repository": "git+https://github.com/mobb-dev/bugsy.git",
   "main": "dist/index.mjs",