@readymadeit/mcp 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,182 @@
+import { AppInstance, ServiceClass } from "hkp-frontend/src/types";
+import ServiceBase from "./ServiceBase";
+import {
+  THIS_DEVICE,
+  resolveCredential,
+} from "hkp-frontend/src/core/secrets";
+import SignUI from "./SignUI";
+
+/**
+ * Service Documentation
+ * Service ID: hookup.to/service/sign
+ * Service Name: Sign
+ * Input:  any — stringified before signing
+ * Output: hex or base64 HMAC string
+ * Config: method ("HmacSHA256" | "HmacSHA512" | "HmacSHA1" | "HmacSHA256p"),
+ *         encoding ("hex" | "base64"), secret (string)
+ *
+ * HmacSHA256p is a progressive mode: chunks are buffered and the HMAC over all
+ * buffered data is produced when configure({ finalize: true }) is called.
+ *
+ * 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.
+ */
+
+const serviceId = "hookup.to/service/sign";
+const serviceName = "Sign";
+
+const METHODS = ["HmacSHA256", "HmacSHA256p", "HmacSHA512", "HmacSHA1"] as const;
+type Method = (typeof METHODS)[number];
+const ENCODINGS = ["hex", "base64"] as const;
+type Encoding = (typeof ENCODINGS)[number];
+
+type State = {
+  methods: readonly string[];
+  method: Method;
+  encodings: readonly string[];
+  encoding: Encoding;
+  secret: string;
+};
+
+const HASH_FOR_HMAC: Partial<Record<Method, string>> = {
+  HmacSHA256:  "SHA-256",
+  HmacSHA256p: "SHA-256",
+  HmacSHA512:  "SHA-512",
+  HmacSHA1:    "SHA-1",
+};
+
+function toHex(buffer: ArrayBuffer): string {
+  return Array.from(new Uint8Array(buffer))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+function toBase64(buffer: ArrayBuffer): string {
+  return btoa(String.fromCharCode(...new Uint8Array(buffer)));
+}
+
+function encode(buffer: ArrayBuffer, encoding: Encoding): string {
+  return encoding === "base64" ? toBase64(buffer) : toHex(buffer);
+}
+
+async function hmac(
+  hash: string,
+  secret: string,
+  data: Uint8Array<ArrayBuffer>,
+): Promise<ArrayBuffer> {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash },
+    false,
+    ["sign"],
+  );
+  return crypto.subtle.sign("HMAC", key, data);
+}
+
+class Sign extends ServiceBase<State> {
+  private _progressiveChunks: Uint8Array<ArrayBuffer>[] = [];
+
+  constructor(app: AppInstance, board: string, descriptor: ServiceClass, id: string) {
+    super(app, board, descriptor, id, {
+      methods: METHODS,
+      method: "HmacSHA256",
+      encodings: ENCODINGS,
+      encoding: "hex",
+      secret: "secret key 123",
+    });
+  }
+
+  configure(config: any) {
+    if (config.method !== undefined) {
+      this.state.method = config.method;
+      this._progressiveChunks = [];
+      this.app.notify(this, { method: config.method });
+    }
+    if (config.encoding !== undefined) {
+      this.state.encoding = config.encoding;
+      this.app.notify(this, { encoding: config.encoding });
+    }
+    if (config.secret !== undefined) {
+      this.state.secret = config.secret;
+      this.app.notify(this, { secret: config.secret });
+    }
+    if (config.finalize === true && this.state.method === "HmacSHA256p") {
+      this.finalizeProgressive();
+    }
+  }
+
+  async process(params: any): Promise<string | null> {
+    const hash = HASH_FOR_HMAC[this.state.method];
+    if (!hash) {
+      console.warn("Sign: unknown method", this.state.method);
+      return null;
+    }
+
+    const data = this.toBytes(params);
+
+    if (this.state.method === "HmacSHA256p") {
+      this._progressiveChunks.push(data);
+      return null; // accumulates until finalize
+    }
+
+    const secret = this.signingKey();
+    if (secret === null) {
+      return null;
+    }
+    const sig = await hmac(hash, secret, data);
+    return encode(sig, this.state.encoding);
+  }
+
+  private async finalizeProgressive() {
+    if (this._progressiveChunks.length === 0) { return; }
+    const totalLength = this._progressiveChunks.reduce((n, c) => n + c.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of this._progressiveChunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    this._progressiveChunks = [];
+    const secret = this.signingKey();
+    if (secret === null) {
+      return;
+    }
+    const sig = await hmac("SHA-256", secret, combined);
+    this.app.next(this, encode(sig, this.state.encoding));
+  }
+
+  /**
+   * The key to sign with, for one signature, or null with the reason reported.
+   *
+   * Resolved per signature rather than once at configure time, so nothing here
+   * ever holds the value: the state this service reports stays the reference it
+   * was configured with.
+   */
+  private signingKey(): string | null {
+    const { value, problem } = resolveCredential(this.state.secret, THIS_DEVICE);
+    if (problem) {
+      this.pushErrorNotification(`Sign: ${problem}`);
+      return null;
+    }
+    return value;
+  }
+
+  private toBytes(params: any): Uint8Array<ArrayBuffer> {
+    const msg = typeof params === "string" ? params : JSON.stringify(params);
+    return new TextEncoder().encode(msg);
+  }
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (app: AppInstance, board: string, descriptor: ServiceClass, id: string) =>
+    new Sign(app, board, descriptor, id),
+  createUI: SignUI,
+};
+
+export default descriptor;

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

@@ -0,0 +1,55 @@
+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";
+import { Button } from "hkp-frontend/src/ui-components/primitives/button";
+
+export default function SignUI(props: ServiceUIProps) {
+  const { service } = props;
+  const [state, setState] = useState<any>({});
+
+  const toOptions = (arr: string[] = []) =>
+    arr.reduce((a: any, c: string) => ({ ...a, [c]: c }), {});
+
+  return (
+    <ServiceUI
+      {...props}
+      onInit={(s: any) => setState(s)}
+      onNotification={(n: any) => setState((prev: any) => ({ ...prev, ...n }))}
+    >
+      <div style={{ minWidth: 250 }}>
+        <SelectorField
+          label="Method"
+          options={toOptions(state.methods)}
+          value={state.method}
+          onChange={({ value }) => service.configure({ method: value })}
+        />
+        <SelectorField
+          label="Encoding"
+          options={toOptions(state.encodings)}
+          value={state.encoding}
+          onChange={({ value }) => service.configure({ encoding: 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 })}
+        />
+        {state.method === "HmacSHA256p" && (
+          <Button
+            variant="outline"
+            className="hkp-svc-btn w-full mt-2"
+            onClick={() => service.configure({ finalize: true })}
+          >
+            Finalize
+          </Button>
+        )}
+      </div>
+    </ServiceUI>
+  );
+}

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

@@ -0,0 +1,101 @@
+import { AppInstance, ServiceClass } from "hkp-frontend/src/types";
+import ServiceBase from "./ServiceBase";
+import SmoothUI from "./SmoothUI";
+
+/**
+ * Service Documentation
+ * Service ID: hookup.to/service/smooth
+ * Service Name: Smooth
+ * Input:  number | object with numeric fields
+ * Output: same shape as input, values blended toward the input each frame
+ * Config: factor (0–1) — how quickly current tracks target (0 = frozen, 1 = instant)
+ *
+ * Maintains a running "current" value and applies EMA each frame:
+ *   current += (target - current) * factor
+ * On the first frame the current is initialized to the input directly.
+ * A reset() call (via configure({ reset: true })) clears the current value.
+ */
+
+const serviceId = "hookup.to/service/smooth";
+const serviceName = "Smooth";
+
+type State = { factor: number };
+
+class Smooth extends ServiceBase<State> {
+  private current: any = undefined;
+
+  constructor(
+    app: AppInstance,
+    board: string,
+    descriptor: ServiceClass,
+    id: string,
+  ) {
+    super(app, board, descriptor, id, { factor: 0.1 });
+  }
+
+  configure(config: any) {
+    if (config?.factor !== undefined) {
+      this.state.factor = Math.max(0, Math.min(1, Number(config.factor)));
+      this.app.notify(this, { factor: this.state.factor });
+    }
+    if (config?.reset) {
+      this.current = undefined;
+    }
+    return this.state;
+  }
+
+  process(params: any): any {
+    if (params == null) {
+      return params;
+    }
+
+    if (this.current === undefined) {
+      this.current = deepCopy(params);
+      return this.current;
+    }
+
+    const { factor } = this.state;
+
+    if (typeof params === "number") {
+      this.current += (params - this.current) * factor;
+      return this.current;
+    }
+
+    if (typeof params === "object") {
+      for (const key of Object.keys(params)) {
+        const target = params[key];
+        if (typeof target === "number") {
+          const cur =
+            typeof this.current[key] === "number" ? this.current[key] : target;
+          this.current[key] = cur + (target - cur) * factor;
+        } else {
+          this.current[key] = target;
+        }
+      }
+      return this.current;
+    }
+
+    return params;
+  }
+}
+
+function deepCopy(x: any): any {
+  if (typeof x === "object" && x !== null) {
+    return { ...x };
+  }
+  return x;
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (
+    app: AppInstance,
+    board: string,
+    descriptor: ServiceClass,
+    id: string,
+  ) => new Smooth(app, board, descriptor, id),
+  createUI: SmoothUI,
+};
+
+export default descriptor;

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

@@ -0,0 +1,50 @@
+import { useState } from "react";
+import ServiceUI from "hkp-frontend/src/ui-components/service/ServiceUI";
+import { ServiceUIProps } from "hkp-frontend/src/types";
+import Knob from "hkp-frontend/src/ui-components/Knob";
+import Button from "hkp-frontend/src/ui-components/Button";
+
+export default function SmoothUI(props: ServiceUIProps) {
+  const { service } = props;
+  const [factor, setFactor] = useState(0.1);
+
+  return (
+    <ServiceUI
+      {...props}
+      onInit={(state: any) => {
+        if (state.factor !== undefined) {
+          setFactor(state.factor);
+        }
+      }}
+      onNotification={(n: any) => {
+        if (n.factor !== undefined) {
+          setFactor(n.factor);
+        }
+      }}
+    >
+      <div style={{ padding: 8, fontFamily: "monospace", fontSize: 12 }}>
+        <div style={{ display: "flex", alignItems: "center", gap: 8 }}>
+          <Knob
+            value={factor}
+            min={0}
+            max={1}
+            width={52}
+            height={52}
+            label={factor.toFixed(2)}
+            onChange={(v) => {
+              setFactor(v);
+              service.configure({ factor: v });
+            }}
+          />
+          <span>Factor</span>
+        </div>
+        <Button
+          className="hkp-svc-btn mt-2 w-full"
+          onClick={() => service.configure({ reset: true })}
+        >
+          Reset
+        </Button>
+      </div>
+    </ServiceUI>
+  );
+}

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

@@ -0,0 +1,59 @@
+import { AppInstance, ServiceClass } from "hkp-frontend/src/types";
+import ServiceBase from "./ServiceBase";
+import SortUI from "./SortUI";
+
+const serviceId = "hookup.to/service/sort";
+const serviceName = "Sort";
+
+export type Direction = "asc" | "desc";
+
+type State = {
+  by: string;
+  dir: Direction;
+};
+
+class Sort extends ServiceBase<State> {
+  constructor(app: AppInstance, board: string, descriptor: ServiceClass, id: string) {
+    super(app, board, descriptor, id, { by: "", dir: "desc" });
+  }
+
+  configure(config: any) {
+    if (config?.by !== undefined) {
+      this.state.by = String(config.by);
+      this.app.notify(this, { by: this.state.by });
+    }
+    if (config?.dir !== undefined) {
+      this.state.dir = config.dir;
+      this.app.notify(this, { dir: this.state.dir });
+    }
+    return this.state;
+  }
+
+  process(params: any): any {
+    if (!Array.isArray(params) || !this.state.by) {
+      return params;
+    }
+    const { by, dir } = this.state;
+    return [...params].sort((a, b) => {
+      const av = a[by];
+      const bv = b[by];
+      if (av < bv) {
+        return dir === "asc" ? -1 : 1;
+      }
+      if (av > bv) {
+        return dir === "asc" ? 1 : -1;
+      }
+      return 0;
+    });
+  }
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (app: AppInstance, board: string, descriptor: ServiceClass, id: string) =>
+    new Sort(app, board, descriptor, id),
+  createUI: SortUI,
+};
+
+export default descriptor;

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

@@ -0,0 +1,61 @@
+import { useState } from "react";
+import ServiceUI from "hkp-frontend/src/ui-components/service/ServiceUI";
+import Select from "hkp-frontend/src/ui-components/Select";
+import { ServiceUIProps } from "hkp-frontend/src/types";
+import type { Direction } from "./Sort";
+
+const DIRECTIONS: Direction[] = ["asc", "desc"];
+
+export default function SortUI(props: ServiceUIProps) {
+  const { service } = props;
+  const [by, setBy] = useState("");
+  const [dir, setDir] = useState<Direction>("desc");
+
+  return (
+    <ServiceUI
+      {...props}
+      onInit={(state: any) => {
+        if (state.by !== undefined) {
+          setBy(state.by);
+        }
+        if (state.dir !== undefined) {
+          setDir(state.dir);
+        }
+      }}
+      onNotification={(n: any) => {
+        if (n.by !== undefined) {
+          setBy(n.by);
+        }
+        if (n.dir !== undefined) {
+          setDir(n.dir);
+        }
+      }}
+    >
+      <div style={{ padding: 8, fontFamily: "monospace", fontSize: 12 }}>
+        <div style={{ display: "flex", alignItems: "center", gap: 6 }}>
+          By:
+          <input
+            type="text"
+            value={by}
+            style={{ width: 80 }}
+            onChange={(e) => {
+              setBy(e.target.value);
+              service.configure({ by: e.target.value });
+            }}
+          />
+        </div>
+        <div style={{ marginTop: 6, display: "flex", alignItems: "center", gap: 6 }}>
+          Dir:
+          <Select
+            options={DIRECTIONS}
+            value={dir}
+            onChange={(v) => {
+              setDir(v as Direction);
+              service.configure({ dir: v });
+            }}
+          />
+        </div>
+      </div>
+    </ServiceUI>
+  );
+}