How to use Extism .NET SDK with PowerShell (2)

[StSchnell]

The first example shows how to use the standard count_vowels. This was important, because simply to show that PowerShell can also be used with the Extism .NET SDK. PowerShell is often used to automate repetitive tasks and is frequently used in companies. A combined application of PowerShell and WebAssembly can certainly be used very profitably in some places. That's why I took a look at the parameter passing options. We discussed this in another context briefly in Discord and it was suggested to use JSON.

To build a WASM file I use the Extism C-PDK and I decided to use JSMN (Jasmine) a minimalistic JSON parser in C. As a realization example, I chose a simple addition of two numbers. The focus of this post is on the data transfer between PowerShell and WebAssembly and vice versa. The following example gives us a basis.

We start with the file addition.h. The logic is not complex, so the code is easy to understand. The function _addition initialize the JSON parser and parses the input, which is split into tokens. In the following loop we get the key and the value of the JSON property and assign it to our variables. We add them and return the result as a string in JSON.

/*
 * fileName: addition.h
 */

// Helper function to get the key or the value of a JSON property
char* _getKeyOrValue(char* json, jsmntok_t* token) {
  int length = token->end - token->start;
  char* value = malloc(length + 1);
  memset(value, '\0', length + 1);
  strncpy(value, json + token->start, length);
  return value;
}

char* _addition(char* additionItems) {

  int summand1 = 0;
  int summand2 = 0;

  // JSON parser intialization and input parsing
  jsmn_parser parser;
  jsmntok_t tokens[5];

  jsmn_init(&parser);
  jsmn_parse(&parser, additionItems, strlen(additionItems), tokens, 5);

  // Loop over the tokens
  for (int i = 1; i <= tokens[0].size * 2; i += 2) {

    char* keySummand = _getKeyOrValue(additionItems, &tokens[i]);
    char* valueSummand = _getKeyOrValue(additionItems, &tokens[i + 1]);

    if (strcmp(keySummand, "summand1") == 0) {
      summand1 = atoi(valueSummand);
    } else if (strcmp(keySummand, "summand2") == 0) {
      summand2 = atoi(valueSummand);
    }

  }

  // Addition
  int sum = summand1 + summand2;

  // Build return value
  char strSum[128];
  sprintf(strSum, "%i", sum);

  char* ret = "{\"sum\":";
  strcat(ret, strSum);
  strcat(ret, "}");

  return ret;

}

Now the file addition.c. There is not much to say about this, it is standard. Exceptions are the additional header files and the call of the addition function.

/*
 * fileName: addition.c
 */

#define EXTISM_ENABLE_LOW_LEVEL_API
#define EXTISM_IMPLEMENTATION
#include "extism-pdk.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "jsmn.h"

#include "addition.h"

int32_t EXTISM_EXPORTED_FUNCTION(addition) {

  const int maxInputLen = 256;

  uint64_t inputLen = extism_input_length();
  if (inputLen == 0) {
    return 0;
  } else if (inputLen > maxInputLen) {
    inputLen = maxInputLen;
  }

  uint8_t inputData[maxInputLen];
  extism_load_input(0, inputData, inputLen);
  inputData[inputLen] = '\0';

  char* additionItems = (char*)inputData;
  char* additionValue = _addition(additionItems);

  int additionValueLen = strlen(additionValue) + 1;
  char answer[128];
  int numberOfChars = snprintf(answer, additionValueLen, "%s", additionValue);

  ExtismHandle buffer = extism_alloc(numberOfChars);
  extism_store(buffer, answer, numberOfChars);
  extism_output_set(buffer, numberOfChars);

  return 0;

}

Now the file addition.ps1. For the most part it is identically to the code presented in the first example. Only the definition of the input parameters is now JSON and so is the return.

<#
 # fileName: addition.ps1
 #
 # Checked with PowerShell 7.5.0 Core on Windows 11 and Photon OS 4
 #>

[String]$LibDir = $($PSScriptRoot)
[String]$Extism = $($LibDir) + "/Extism.Sdk.dll"
Add-Type -Path $Extism

function Main {

  [System.String]$wasmFileName = "$($PSScriptRoot)/addition.wasm"

  try {

    [System.Array]$wasmFileArrayOfBytes = `
      Get-Content -Path $wasmFileName -AsByteStream -Raw

    $wasmArray = [Extism.Sdk.ByteArrayWasmSource]::new( `
      $wasmFileArrayOfBytes, `
      "addition.wasm" `
    )

    $Manifest = [Extism.Sdk.Manifest]::new($wasmArray)

    $Options = [Extism.Sdk.PluginIntializationOptions]::new()
    $Options.WithWasi = $True

    $HostFunctionArray = [Extism.Sdk.HostFunction[]]::new(0)

    $Plugin = [Extism.Sdk.Plugin]::new($Manifest, $HostFunctionArray, $Options)

    $additionItems = @"
    {
      "summand1": 22,
      "summand2": 20
    }
"@

    $additionValue = $Plugin.Call("addition", $additionItems) | ConvertFrom-Json
    Write-Host $additionValue     # @{sum=42}
    Write-Host $additionValue.sum # 42

  } catch {
    Write-Host "An error occurred:"
    Write-Host $_
  }

}

Main

We can conclude (with greater certainty) that it is possible to use the Extism .NET SDK with PowerShell. It was important for me to show here that data can be passed on in JSON format. This means that a lot is possible.

[mhmd-azeez]

@StSchnell thank you very much for this detailed tutorial! This is very helpful for windows admins and people who use PowerShell daily