Merge pull request #1 from Esonhugh/feat/http-repeater

Feat/http repeater

Author: Esonhugh

package.json

@@ -268,6 +268,7 @@
     "test": "vscode-test"
   },
   "devDependencies": {
+    "@types/http-string-parser": "^0.0.33",
     "@types/mocha": "^10.0.10",
     "@types/node": "~20.19.1",
     "@types/vscode": "^1.101.0",
@@ -284,6 +285,7 @@
     "webpack-cli": "^6.0.1"
   },
   "dependencies": {
+    "http-string-parser": "^0.0.6",
     "table": "^6.9.0",
     "vscode-variables": "^1.0.1",
     "yaml": "^2.8.0"

pnpm-lock.yaml

@@ -0,0 +1,53 @@
+import * as vscode from "vscode";
+import { logger } from "../../global/log";
+
+export type MarkdownHTTPCodeLensGenerator = (
+  post: string[],
+  startLine: number,
+  document: vscode.TextDocument
+) => vscode.CodeLens[];
+
+export class MarkdownHTTPCodeLensProvider implements vscode.CodeLensProvider {
+  private generators: MarkdownHTTPCodeLensGenerator[];
+  constructor(...generators: MarkdownHTTPCodeLensGenerator[]) {
+    this.generators = generators;
+  }
+
+  provideCodeLenses(
+    document: vscode.TextDocument,
+    token: vscode.CancellationToken
+  ): vscode.ProviderResult<vscode.CodeLens[]> {
+    const codeLenses: vscode.CodeLens[] = [];
+    const lines = document.getText().split("\n");
+
+    let inYaml = false;
+    let currentPost = [];
+    let yamlStartLine = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (inYaml) {
+        if (line === "```") {
+          for (const generator of this.generators) {
+            try {
+              codeLenses.push(
+                ...generator(currentPost, yamlStartLine, document)
+              );
+            } catch (error) {
+              logger.error("Error generating code lenses: ", error);
+            }
+          }
+          inYaml = false;
+          currentPost = [];
+        } else {
+          currentPost.push(line);
+        }
+      } else if (line.startsWith("```http")) {
+        inYaml = true;
+        yamlStartLine = i;
+      }
+    }
+
+    return codeLenses;
+  }
+}

src/codelens/httpreapter/base.ts

@@ -0,0 +1,4 @@
+import { MarkdownHTTPCodeLensProvider } from "./base";
+import { httpRepeaterCodeLens } from "./send";
+
+export const httpRepeater = new MarkdownHTTPCodeLensProvider(httpRepeaterCodeLens);

src/codelens/httpreapter/index.ts

@@ -0,0 +1,44 @@
+import { MarkdownHTTPCodeLensGenerator } from "./base";
+import * as vscode from "vscode";
+
+export const httpRepeaterCodeLens: MarkdownHTTPCodeLensGenerator = (post: string[], startLine: number, document: vscode.TextDocument): vscode.CodeLens[] => {
+  const codeLenses: vscode.CodeLens[] = [];
+  const cmd: vscode.Command = {
+    title: "Send HTTP Request",
+    command: "weapon.http_raw_request",
+    arguments: [
+      {
+        request: post.join("\r\n"),
+        isHTTPS: false,
+      },
+    ],
+  };
+  let cmd2: vscode.Command = {
+    title: "Send HTTPS Request",
+    command: "weapon.http_raw_request",
+    arguments: [
+      {
+        request: post.join("\r\n"),
+        isHTTPS: true,
+      },
+    ],
+  };
+  codeLenses.push(
+    new vscode.CodeLens(
+      new vscode.Range(
+        new vscode.Position(startLine, 0),
+        new vscode.Position(startLine + 1, 0)
+      ),
+      cmd
+    ),
+    new vscode.CodeLens(
+      new vscode.Range(
+        new vscode.Position(startLine, 0),
+        new vscode.Position(startLine + 1, 0)
+      ),
+      cmd2
+    )
+  );
+
+  return codeLenses;
+};

src/codelens/httpreapter/send.ts

@@ -3,6 +3,7 @@ import { targetFilePattern } from "../global/const";
 import { markdownCodelens } from "./yamlconfig";
 import { CommandCodeLensProvider } from "./command/commandProvider";
 import { NoteCreationProvider } from "./newnote/noteProvider";
+import { httpRepeater } from "./httpreapter";
 
 export function registerCodeLensProviders(context: vscode.ExtensionContext) {
   context.subscriptions.push(
@@ -18,5 +19,9 @@ export function registerCodeLensProviders(context: vscode.ExtensionContext) {
       { language: "markdown", scheme: "file", pattern: targetFilePattern },
       new NoteCreationProvider()
     ),
+    vscode.languages.registerCodeLensProvider(
+      { language: "markdown", scheme: "file", pattern: targetFilePattern },
+      httpRepeater
+    )
   );
 }

src/codelens/index.ts

@@ -0,0 +1,71 @@
+import { callback } from "../utils";
+import { parseRequest, ParseRequestResult } from "http-string-parser";
+import * as vscode from "vscode";
+import { logger } from "../../global/log";
+
+export const rawHTTPRequest: callback = async (args) => {
+  let request: string | undefined = args.request ? args.request : undefined;
+  if (!request) {
+    vscode.window.showErrorMessage("No request provided");
+    return;
+  }
+  let isHTTPS = args.isHTTPS ? args.isHTTPS : false;
+
+  let res: ParseRequestResult;
+  try {
+    res = parseRequest(request);
+    if (!res) {
+      logger.error("Failed to parse request", request);
+      vscode.window.showErrorMessage("Invalid request format");
+      return;
+    }
+  } catch (e: any) {
+    logger.error("raise Error parsing request", e);
+    vscode.window.showErrorMessage(`Error parsing request: ${e.message}`);
+    return;
+  }
+  try {
+    const { method, uri, headers, body } = res;
+    var url = headers["Host"]
+      ? `${isHTTPS ? "https" : "http"}://${headers["Host"]}${uri}`
+      : uri;
+    logger.debug(
+      `sending request: ${method} ${url}, headers: ${JSON.stringify(
+        headers
+      )}, body: ${body ? body : "none"}`
+    );
+    let response: Response | undefined = undefined;
+    if (method === "GET" || method === "HEAD") {
+      // For GET and HEAD requests, we should not send a body
+      response = await fetch(url, {
+        method,
+        headers,
+      });
+    } else {
+      response = await fetch(url, {
+        method,
+        headers,
+        body,
+      });
+    }
+    let responseText: string = `HTTP/1.1 ${response.status} ${response.statusText}\n`;
+    for (const [key, value] of response.headers.entries()) {
+      responseText += `${key}: ${value}\n`;
+    }
+    responseText += "\n" + (await response.text());
+
+    await vscode.window.showTextDocument(
+      vscode.Uri.parse(
+        "weaponized-editor:response.http?" + encodeURIComponent(responseText)
+      ),
+      {
+        preview: false,
+        viewColumn: vscode.ViewColumn.Beside,
+      }
+    );
+  } catch (e: any) {
+    logger.error("raise Error fetching request", e);
+    vscode.window.showErrorMessage(`Error fetching request: ${e.message}`);
+    return;
+  }
+};

src/commands/http/request.ts

@@ -11,6 +11,7 @@ import { switchActiveHost } from "./switch/host";
 import { switchActiveUser } from "./switch/user";
 import { cyberChefMagicDecoder } from "./decoder/cyberchef";
 import { copyCommand } from "./copy/copy";
+import { rawHTTPRequest } from "./http/request";
 
 export function registerCommandsPackage(context: vscode.ExtensionContext) {
   context.subscriptions.push(
@@ -42,6 +43,9 @@ export function registerCommandsPackage(context: vscode.ExtensionContext) {
     vscode.workspace.registerTextDocumentContentProvider(
       "weaponized-editor",
       new ReadOnlyProvider()
-    )
-  );
+    ),
+    vscode.commands.registerCommand(
+      "weapon.http_raw_request",
+      rawHTTPRequest
+  ));
 }