@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-frontend/src/runtime/browser/services/Encode.ts

@@ -0,0 +1,138 @@
+/**
+ * Service Documentation
+ * Service ID: hookup.to/service/encode
+ * Service Name: Encode
+ * Modes: base64-encode | base64-decode | url-encode | url-decode | hex-encode | hex-decode
+ * Key Config: mode (default: "base64-encode")
+ * IO: in=string|any -> out=string|any
+ *
+ * base64-encode: UTF-8-safe base64. Non-string inputs are JSON-stringified first.
+ * base64-decode: Decodes a base64 string; if the result is valid JSON it is parsed.
+ * url-encode:    Applies encodeURIComponent. Non-strings are JSON-stringified first.
+ * url-decode:    Applies decodeURIComponent; tries JSON.parse on the result.
+ * hex-encode:    Encodes to hex (lowercase). Non-strings are JSON-stringified first.
+ * hex-decode:    Decodes a hex string back to UTF-8; tries JSON.parse on the result.
+ */
+
+import { AppInstance, ServiceClass } from "hkp-frontend/src/types";
+import ServiceBase from "./ServiceBase";
+import EncodeUI from "./EncodeUI";
+import { EncodeMode } from "./encode-modes";
+
+const serviceId = "hookup.to/service/encode";
+const serviceName = "Encode";
+
+type State = { mode: EncodeMode };
+
+function toUtf8Base64(str: string): string {
+  const bytes = new TextEncoder().encode(str);
+  let binary = "";
+  for (const b of bytes) {
+    binary += String.fromCharCode(b);
+  }
+  return btoa(binary);
+}
+
+function fromUtf8Base64(b64: string): string {
+  const bytes = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+
+function serialize(input: any): string {
+  return typeof input === "string" ? input : JSON.stringify(input);
+}
+
+function tryParseJson(str: string): any {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+}
+
+function toHex(str: string): string {
+  return Array.from(new TextEncoder().encode(str))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+function fromHex(hex: string): string {
+  const clean = hex.replace(/\s/g, "");
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return new TextDecoder().decode(bytes);
+}
+
+class Encode extends ServiceBase<State> {
+  constructor(
+    app: AppInstance,
+    board: string,
+    descriptor: ServiceClass,
+    id: string,
+  ) {
+    super(app, board, descriptor, id, { mode: "base64-encode" });
+  }
+
+  configure(config: Partial<State>) {
+    if (config.mode !== undefined) {
+      this.state.mode = config.mode;
+      this.app.notify(this, { mode: config.mode });
+    }
+  }
+
+  process(input: any): any {
+    switch (this.state.mode) {
+      case "base64-encode":
+        return toUtf8Base64(serialize(input));
+
+      case "base64-decode": {
+        try {
+          return tryParseJson(fromUtf8Base64(serialize(input)));
+        } catch {
+          this.pushErrorNotification("Encode: invalid base64 input");
+          return null;
+        }
+      }
+
+      case "url-encode":
+        return encodeURIComponent(serialize(input));
+
+      case "url-decode": {
+        try {
+          return tryParseJson(decodeURIComponent(serialize(input)));
+        } catch {
+          this.pushErrorNotification("Encode: invalid URL-encoded input");
+          return null;
+        }
+      }
+
+      case "hex-encode":
+        return toHex(serialize(input));
+
+      case "hex-decode": {
+        try {
+          return tryParseJson(fromHex(serialize(input)));
+        } catch {
+          this.pushErrorNotification("Encode: invalid hex input");
+          return null;
+        }
+      }
+    }
+  }
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (
+    app: AppInstance,
+    board: string,
+    descriptor: ServiceClass,
+    id: string,
+  ) => new Encode(app, board, descriptor, id),
+  createUI: EncodeUI,
+};
+
+export default descriptor;

package/bundle/hkp-frontend/src/runtime/browser/services/EncodeUI.tsx

@@ -0,0 +1,52 @@
+import { useState } from "react";
+import ServiceUI from "hkp-frontend/src/ui-components/service/ServiceUI";
+import { ServiceUIProps } from "hkp-frontend/src/types";
+import SelectorField from "hkp-frontend/src/components/shared/SelectorField";
+import { ENCODE_MODES, type EncodeMode } from "./encode-modes";
+
+const MODE_LABELS: Record<EncodeMode, string> = {
+  "base64-encode": "Base64 Encode",
+  "base64-decode": "Base64 Decode",
+  "url-encode": "URL Encode",
+  "url-decode": "URL Decode",
+  "hex-encode": "Hex Encode",
+  "hex-decode": "Hex Decode",
+};
+
+const modeOptions = ENCODE_MODES.reduce(
+  (acc, m) => ({ ...acc, [m]: MODE_LABELS[m] }),
+  {} as Record<string, string>,
+);
+
+export default function EncodeUI(props: ServiceUIProps) {
+  const { service } = props;
+  const [mode, setMode] = useState<EncodeMode>("base64-encode");
+
+  return (
+    <ServiceUI
+      {...props}
+      onInit={(s: any) => {
+        if (s.mode) {
+          setMode(s.mode);
+        }
+      }}
+      onNotification={(n: any) => {
+        if (n.mode) {
+          setMode(n.mode);
+        }
+      }}
+    >
+      <div className="flex flex-col" style={{ minWidth: 220 }}>
+        <SelectorField
+          label="Mode"
+          options={modeOptions}
+          value={mode}
+          onChange={({ value }) => {
+            setMode(value as EncodeMode);
+            service.configure({ mode: value });
+          }}
+        />
+      </div>
+    </ServiceUI>
+  );
+}

package/bundle/hkp-frontend/src/runtime/browser/services/Encrypt.ts

@@ -0,0 +1,125 @@
+import { AppInstance, ServiceClass } from "hkp-frontend/src/types";
+import ServiceBase from "./ServiceBase";
+import {
+  THIS_DEVICE,
+  resolveCredential,
+} from "hkp-frontend/src/core/secrets";
+import EncryptUI from "./EncryptUI";
+
+/**
+ * Service Documentation
+ * Service ID: hookup.to/service/encrypt
+ * Service Name: Encrypt
+ * Input:  any — JSON-serialisable value or Blob/File
+ * Output: base64 string — [12-byte IV][AES-256-GCM ciphertext]
+ * Config: secret (string), method ("aes" — only option for now)
+ *
+ * The secret is a `{{secret.<alias>}}` reference resolved at the moment a key is
+ * derived from it, and never held as a value: it is not sent anywhere, so it
+ * resolves against `THIS_DEVICE`, and a secret whose audience is that one is
+ * refused everywhere on the network. What the service reports from its state is
+ * the reference it was configured with, which is what a saved board carries.
+ *
+ * Key derivation: SHA-256 of the UTF-8 encoded secret → 256-bit AES-GCM key.
+ * A fresh 12-byte random IV is generated per encrypt call and prepended to
+ * the ciphertext. Blob/File inputs are base64-encoded before encryption so
+ * the decrypt service can reconstruct them.
+ */
+
+const serviceId = "hookup.to/service/encrypt";
+const serviceName = "Encrypt";
+
+const METHODS = ["aes"] as const;
+type Method = (typeof METHODS)[number];
+
+type State = {
+  secret: string;
+  method: Method;
+  methods: readonly string[];
+};
+
+async function deriveKey(secret: string, usage: KeyUsage): Promise<CryptoKey> {
+  const raw = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(secret),
+  );
+  return crypto.subtle.importKey("raw", raw, { name: "AES-GCM" }, false, [usage]);
+}
+
+async function blobToBase64(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const url = reader.result as string;
+      resolve(url.split(";base64,")[1]);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+
+class Encrypt extends ServiceBase<State> {
+  constructor(app: AppInstance, board: string, descriptor: ServiceClass, id: string) {
+    super(app, board, descriptor, id, {
+      secret: "",
+      method: "aes",
+      methods: METHODS,
+    });
+  }
+
+  configure(config: any) {
+    if (config.secret !== undefined) {
+      this.state.secret = config.secret;
+      this.app.notify(this, { secret: config.secret });
+    }
+    if (config.method !== undefined) {
+      this.state.method = config.method;
+      this.app.notify(this, { method: config.method });
+    }
+  }
+
+  async process(params: any): Promise<string | null> {
+    if (!this.state.secret) {
+      this.pushErrorNotification("Encrypt: no secret configured");
+      return null;
+    }
+
+    // The passphrase exists from here to the end of this call and nowhere else.
+    const { value: secret, problem } = resolveCredential(
+      this.state.secret,
+      THIS_DEVICE,
+    );
+    if (problem) {
+      this.pushErrorNotification(`Encrypt: ${problem}`);
+      return null;
+    }
+
+    const isBlob = params instanceof Blob || params instanceof File;
+    const plaintext = isBlob
+      ? JSON.stringify({ __blob: await blobToBase64(params) })
+      : JSON.stringify(params);
+
+    const key = await deriveKey(secret, "encrypt");
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const ciphertext = await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      new TextEncoder().encode(plaintext),
+    );
+
+    const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+    combined.set(iv);
+    combined.set(new Uint8Array(ciphertext), iv.length);
+    return btoa(String.fromCharCode(...combined));
+  }
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (app: AppInstance, board: string, descriptor: ServiceClass, id: string) =>
+    new Encrypt(app, board, descriptor, id),
+  createUI: EncryptUI,
+};
+
+export default descriptor;

package/bundle/hkp-frontend/src/runtime/browser/services/EncryptUI.tsx

@@ -0,0 +1,39 @@
+import { useState } from "react";
+import ServiceUI from "hkp-frontend/src/ui-components/service/ServiceUI";
+import { ServiceUIProps } from "hkp-frontend/src/types";
+import SelectorField from "hkp-frontend/src/components/shared/SelectorField";
+import InputField from "hkp-frontend/src/components/shared/InputField";
+
+export default function EncryptUI(props: ServiceUIProps) {
+  const { service } = props;
+  const [state, setState] = useState<any>({});
+
+  return (
+    <ServiceUI
+      {...props}
+      onInit={(s: any) => setState(s)}
+      onNotification={(n: any) => setState((prev: any) => ({ ...prev, ...n }))}
+    >
+      <div className="flex flex-col" style={{ minWidth: 250 }}>
+        <SelectorField
+          label="Method"
+          options={(state.methods ?? ["aes"]).reduce(
+            (a: any, c: string) => ({ ...a, [c]: c }),
+            {},
+          )}
+          value={state.method ?? "aes"}
+          onChange={({ value }) => service.configure({ method: value })}
+        />
+        {/* Not masked: this field holds the *name* of a secret, not a secret.
+            The value lives in the vault and is fetched when a key is derived
+            from it, so hiding what is typed here would hide nothing and make a
+            mistyped alias impossible to spot. */}
+        <InputField
+          label="Secret"
+          value={state.secret ?? ""}
+          onChange={(secret) => service.configure({ secret })}
+        />
+      </div>
+    </ServiceUI>
+  );
+}

package/bundle/hkp-frontend/src/runtime/browser/services/FFT.tsx

@@ -0,0 +1,238 @@
+import { AppInstance, ServiceClass } from "hkp-frontend/src/types";
+import ServiceBase from "./ServiceBase";
+import { isFloatRingBuffer } from "../../rest/Data";
+import FFTUI from "./FFTUI";
+
+const serviceId = "hookup.to/service/fft";
+const serviceName = "FFT";
+
+type WindowFunction = "none" | "hann" | "hamming" | "blackman" | "rectangular";
+type OutputFormat = "magnitude" | "power" | "db";
+
+type State = {
+  windowFunction: WindowFunction;
+  outputFormat: OutputFormat;
+  fftSize: number | null;
+};
+
+class FFT extends ServiceBase<State> {
+  constructor(
+    app: AppInstance,
+    board: string,
+    descriptor: ServiceClass,
+    id: string,
+  ) {
+    super(app, board, descriptor, id, {
+      windowFunction: "none",
+      outputFormat: "magnitude",
+      fftSize: null,
+    });
+  }
+
+  async configure(config: any) {
+    const { windowFunction, outputFormat, fftSize } = config;
+    if (windowFunction !== undefined) {
+      this.state.windowFunction = windowFunction;
+      this.app.notify(this, { windowFunction });
+    }
+    if (outputFormat !== undefined) {
+      this.state.outputFormat = outputFormat;
+      this.app.notify(this, { outputFormat });
+    }
+    if (fftSize !== undefined) {
+      if (fftSize === "auto") {
+        this.state.fftSize = null;
+      } else {
+        this.state.fftSize = fftSize;
+      }
+      this.app.notify(this, { fftSize });
+    }
+
+    return this.state;
+  }
+
+  async process(params: any) {
+    if (isFloatRingBuffer(params)) {
+      const array: Uint8Array = params.array;
+      let floatArray = new Float32Array(
+        array.buffer,
+        array.byteOffset,
+        array.length / 4,
+      );
+
+      // Resize to FFT size (zero-pad or truncate) - only if fftSize is set
+      if (
+        this.state.fftSize !== null &&
+        floatArray.length !== this.state.fftSize
+      ) {
+        const resized = new Float32Array(this.state.fftSize);
+        const copyLength = Math.min(floatArray.length, this.state.fftSize);
+        resized.set(floatArray.subarray(0, copyLength));
+        floatArray = resized;
+      }
+
+      // Apply window function - only if windowFunction is set
+      const processArray =
+        this.state.windowFunction !== null
+          ? applyWindow(floatArray, this.state.windowFunction)
+          : floatArray;
+
+      // Perform FFT
+      const fftResult = realFFT(processArray);
+
+      switch (this.state.outputFormat) {
+        case "magnitude":
+          return fftResult.magnitude;
+        case "power":
+          return fftResult.magnitude.map((m: number) => m * m);
+        case "db":
+          return fftResult.magnitude.map(
+            (m: number) => 20 * Math.log10(Math.max(m, 1e-10)),
+          );
+        default:
+          return fftResult.magnitude;
+      }
+    }
+    return params;
+  }
+}
+
+function applyWindow(
+  signal: Float32Array,
+  windowType: WindowFunction,
+): Float32Array {
+  const N = signal.length;
+  const windowed = new Float32Array(N);
+
+  for (let i = 0; i < N; i++) {
+    let w = 1.0;
+
+    switch (windowType) {
+      case "hann":
+        w = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (N - 1)));
+        break;
+      case "hamming":
+        w = 0.54 - 0.46 * Math.cos((2 * Math.PI * i) / (N - 1));
+        break;
+      case "blackman":
+        w =
+          0.42 -
+          0.5 * Math.cos((2 * Math.PI * i) / (N - 1)) +
+          0.08 * Math.cos((4 * Math.PI * i) / (N - 1));
+        break;
+      case "rectangular":
+        w = 1.0;
+        break;
+    }
+
+    windowed[i] = signal[i] * w;
+  }
+
+  return windowed;
+}
+
+function realFFT(signal: any) {
+  const N = signal.length;
+
+  if ((N & (N - 1)) !== 0) {
+    throw new Error("Length must be a power of 2");
+  }
+
+  // Initialize real and imaginary parts
+  const real = signal.slice(); // copy of input
+  const imag = new Array(N).fill(0);
+
+  // Perform complex FFT
+  fft(real, imag);
+
+  // Return magnitude and phase (or real/imag if you want)
+  const magnitude = new Array(N / 2);
+  const phase = new Array(N / 2);
+
+  for (let i = 0; i < N / 2; i++) {
+    const re = real[i];
+    const im = imag[i];
+    magnitude[i] = Math.hypot(re, im);
+    phase[i] = Math.atan2(im, re);
+  }
+
+  return { real, imag, magnitude, phase };
+}
+
+function fft(real: any, imag: any) {
+  const N = real.length;
+
+  if (N !== imag.length) {
+    throw new Error("Mismatched lengths");
+  }
+  if ((N & (N - 1)) !== 0) {
+    throw new Error("Input length must be a power of 2");
+  }
+
+  // Bit-reversal permutation
+  const bitReversedIndices = new Uint32Array(N);
+  const bits = Math.log2(N);
+  for (let i = 0; i < N; i++) {
+    let j = 0;
+    for (let k = 0; k < bits; k++) {
+      j = (j << 1) | ((i >>> k) & 1);
+    }
+    bitReversedIndices[i] = j;
+  }
+
+  for (let i = 0; i < N; i++) {
+    if (i < bitReversedIndices[i]) {
+      [real[i], real[bitReversedIndices[i]]] = [
+        real[bitReversedIndices[i]],
+        real[i],
+      ];
+      [imag[i], imag[bitReversedIndices[i]]] = [
+        imag[bitReversedIndices[i]],
+        imag[i],
+      ];
+    }
+  }
+
+  // Cooley-Tukey FFT
+  for (let size = 2; size <= N; size *= 2) {
+    const half = size / 2;
+    const theta = (-2 * Math.PI) / size;
+    const wtemp = Math.sin(0.5 * theta);
+    const wpr = -2.0 * wtemp * wtemp;
+    const wpi = Math.sin(theta);
+    let wr = 1.0;
+    let wi = 0.0;
+
+    for (let m = 0; m < half; m++) {
+      for (let i = m; i < N; i += size) {
+        const j = i + half;
+        const tempr = wr * real[j] - wi * imag[j];
+        const tempi = wr * imag[j] + wi * real[j];
+
+        real[j] = real[i] - tempr;
+        imag[j] = imag[i] - tempi;
+
+        real[i] += tempr;
+        imag[i] += tempi;
+      }
+
+      const wtemp = wr;
+      wr += wr * wpr - wi * wpi;
+      wi += wi * wpr + wtemp * wpi;
+    }
+  }
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (
+    app: AppInstance,
+    board: string,
+    descriptor: ServiceClass,
+    id: string,
+  ) => new FFT(app, board, descriptor, id),
+  createUI: FFTUI,
+};
+
+export default descriptor;

package/bundle/hkp-frontend/src/runtime/browser/services/FFTUI.tsx

@@ -0,0 +1,112 @@
+import { ServiceUIProps } from "hkp-frontend/src/types";
+import RuntimeRestServiceUI from "../../rest/RuntimeRestServiceUI";
+import SelectorField, {
+  OnChangeValue,
+} from "hkp-frontend/src/components/shared/SelectorField";
+import { useState } from "react";
+
+type WindowFunction = "none" | "hann" | "hamming" | "blackman" | "rectangular";
+type OutputFormat = "magnitude" | "power" | "db";
+
+const WINDOW_OPTIONS = {
+  none: "None",
+  hann: "Hann",
+  hamming: "Hamming",
+  blackman: "Blackman",
+  rectangular: "Rectangular",
+};
+
+const FORMAT_OPTIONS = {
+  magnitude: "Magnitude",
+  power: "Power",
+  db: "dB Scale",
+};
+
+const FFT_SIZE_OPTIONS = {
+  auto: "Auto",
+  "256": "256",
+  "512": "512",
+  "1024": "1024",
+  "2048": "2048",
+  "4096": "4096",
+  "8192": "8192",
+};
+
+export default function FFTUI(props: ServiceUIProps) {
+  const [windowFunction, setWindowFunction] = useState<WindowFunction>("none");
+  const [outputFormat, setOutputFormat] = useState<OutputFormat>("magnitude");
+  const [fftSize, setFftSize] = useState<string | null>(null);
+
+  const onUpdate = (message: any) => {
+    if (message.windowFunction !== undefined) {
+      setWindowFunction(message.windowFunction);
+    }
+
+    if (message.outputFormat !== undefined) {
+      setOutputFormat(message.outputFormat);
+    }
+
+    if (message.fftSize !== undefined) {
+      setFftSize(message.fftSize);
+    }
+  };
+
+  const onChangeWindow = (value: OnChangeValue) => {
+    const newValue = value.value === "none" ? null : value.value;
+    props.service.configure({ windowFunction: newValue });
+  };
+
+  const onChangeOutput = (value: OnChangeValue) => {
+    const newValue = value.value === "none" ? null : value.value;
+    props.service.configure({ outputFormat: newValue });
+  };
+
+  const onChangeFFTSize = (value: OnChangeValue) => {
+    const newValue = value.value === "none" ? null : value.value;
+    props.service.configure({ fftSize: newValue });
+  };
+
+  return (
+    <RuntimeRestServiceUI
+      {...props}
+      onNotification={onUpdate}
+      onInit={onUpdate}
+      genericUI={false}
+    >
+      <div className="flex mb-4 w-[250px]">
+        <div className="text-sm text-gray-500 flex-col gap-2 flex w-full">
+          <SelectorField
+            value={windowFunction ?? "none"}
+            label="Window"
+            options={WINDOW_OPTIONS}
+            onChange={onChangeWindow}
+            labelStyle={{
+              textTransform: "capitalize",
+              textAlign: "left",
+            }}
+          />
+          <SelectorField
+            value={outputFormat}
+            label="Format"
+            options={FORMAT_OPTIONS}
+            onChange={onChangeOutput}
+            labelStyle={{
+              textTransform: "capitalize",
+              textAlign: "left",
+            }}
+          />
+          <SelectorField
+            value={fftSize ?? "auto"}
+            label="FFTSize"
+            options={FFT_SIZE_OPTIONS}
+            onChange={onChangeFFTSize}
+            labelStyle={{
+              textTransform: "capitalize",
+              textAlign: "left",
+            }}
+          />
+        </div>
+      </div>
+    </RuntimeRestServiceUI>
+  );
+}