@readymadeit/mcp 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,34 @@
+/**
+ * The MediaPipe Tasks Vision models Detect runs, and everything they need,
+ * shipped with the app rather than fetched from a CDN: the native apps must
+ * detect offline. Vite emits each file as an asset of its own, and the
+ * library itself is imported only when a detector is first made — a board
+ * without a Detect service never downloads any of it.
+ *
+ * Only the SIMD build of the Wasm runtime is shipped; every engine the app
+ * runs in (WKWebView, WebView2, Android WebView, current browsers) has SIMD.
+ */
+
+import type { FaceDetector } from "@mediapipe/tasks-vision";
+import wasmLoaderPath from "@mediapipe/tasks-vision/vision_wasm_internal.js?url";
+import wasmBinaryPath from "@mediapipe/tasks-vision/vision_wasm_internal.wasm?url";
+import faceModelPath from "./models/blaze_face_short_range.tflite?url";
+
+export type { FaceDetector };
+
+/** BlazeFace short-range: faces within about two metres of the camera. */
+export async function createFaceDetector(
+  minDetectionConfidence: number,
+): Promise<FaceDetector> {
+  const { FaceDetector } = await import("@mediapipe/tasks-vision");
+  return FaceDetector.createFromOptions(
+    { wasmLoaderPath, wasmBinaryPath },
+    {
+      // The CPU delegate: the model is small enough to run in milliseconds,
+      // and a WebGL context is one more thing a webview may refuse.
+      baseOptions: { modelAssetPath: faceModelPath, delegate: "CPU" },
+      runningMode: "IMAGE",
+      minDetectionConfidence,
+    },
+  );
+}

package/bundle/hkp-frontend/src/runtime/browser/services/detect/models/README.md

@@ -0,0 +1,14 @@
+# Detect models
+
+Models the Detect service runs, shipped with the app so it detects offline.
+Each is emitted by Vite as an asset of its own and loaded only when a Detect
+service first runs (`../mediapipe.ts`).
+
+| File | What | Source | Licence |
+| --- | --- | --- | --- |
+| `blaze_face_short_range.tflite` | BlazeFace short-range face detector, float16 (229,746 bytes, sha256 `b4578f35940bf5a1a655214a1cce5cab13eba73c1297cd78e1a04c2380b0152f`) | https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/latest/blaze_face_short_range.tflite — see the [MediaPipe face detector guide](https://ai.google.dev/edge/mediapipe/solutions/vision/face_detector) and its model card | Apache-2.0, as MediaPipe publishes its solution models |
+
+The Wasm runtime that runs them comes from the `@mediapipe/tasks-vision` npm
+package (Apache-2.0) and is recorded with the other npm dependencies by
+`scripts/collect-licenses.py`. This folder is not: that script discovers
+vendored source under `3rdparty/`, so a model added here is recorded here.

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

@@ -0,0 +1,7 @@
+/** What Detect looks for. Each mode reports its findings under its own key. */
+export const DETECT_MODES = ["face"] as const;
+export type DetectMode = (typeof DETECT_MODES)[number];
+
+export const DETECT_LABELS: { [mode in DetectMode]: string } = {
+  face: "Faces",
+};

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

@@ -0,0 +1,10 @@
+export const ENCODE_MODES = [
+  "base64-encode",
+  "base64-decode",
+  "url-encode",
+  "url-decode",
+  "hex-encode",
+  "hex-decode",
+] as const;
+
+export type EncodeMode = (typeof ENCODE_MODES)[number];

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

@@ -0,0 +1,300 @@
+export function isObject(x: any): boolean {
+  return Object.prototype.toString.call(x) === "[object Object]"; // strict JSON object check
+}
+
+export function isSomeObject(x: any): boolean {
+  return typeof x === "object"; // not true for e.g. [object AnalyserNode], [object Blob], [object String] etc.
+}
+
+export function isFunction(functionToCheck: any): boolean {
+  return (
+    // functionToCheck && {}.toString.call(functionToCheck) === "[object Function]"
+    typeof functionToCheck === "function"
+  );
+}
+
+export function isBlob(data: any): data is Blob {
+  return data instanceof Blob;
+}
+
+export function isArrayBuffer(value: any): value is ArrayBuffer {
+  const hasArrayBuffer = typeof ArrayBuffer === "function";
+  return (
+    hasArrayBuffer &&
+    (value instanceof ArrayBuffer ||
+      toString.call(value) === "[object ArrayBuffer]")
+  );
+}
+
+export function toArrayBuffer(blobOrFile: Blob | File): Promise<ArrayBuffer> {
+  if ((blobOrFile as any).arrayBuffer) {
+    return (blobOrFile as any).arrayBuffer();
+  }
+  return new Promise((resolve, reject) => {
+    const fr = new FileReader();
+    try {
+      fr.onload = () => resolve(fr.result as ArrayBuffer);
+      fr.readAsArrayBuffer(blobOrFile);
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+export function encodeBlobBase64(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve((reader.result as string).split(",")[1]);
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+
+export function filterPrivateMembers(
+  service: Record<string, any> | null | undefined,
+): Record<string, any> | undefined {
+  if (!service) {
+    return undefined;
+  }
+  return Object.keys(service).reduce<Record<string, any>>(
+    (res, cur) =>
+      cur[0] === "_" || cur === "app" ? res : { ...res, [cur]: service[cur] },
+    {},
+  );
+}
+
+const nonConfigServiceKeys = new Set([
+  "uuid",
+  "serviceId",
+  "serviceName",
+  "board",
+  "app",
+  "descriptor",
+  "__descriptor",
+  "state",
+]);
+
+export function extractServiceConfiguration(
+  service: Record<string, any> | null | undefined,
+): Record<string, any> {
+  if (!service) {
+    return {};
+  }
+
+  const publicMembers = filterPrivateMembers(service) || {};
+  const state =
+    service.state && typeof service.state === "object" ? service.state : {};
+  const merged = {
+    ...publicMembers,
+    ...state,
+  };
+
+  return Object.keys(merged).reduce<Record<string, any>>((acc, key) => {
+    if (nonConfigServiceKeys.has(key) || isFunction(merged[key])) {
+      return acc;
+    }
+    return {
+      ...acc,
+      [key]: merged[key],
+    };
+  }, {});
+}
+
+export function createObjectURL(
+  object: ArrayBuffer | Uint8Array | Blob,
+  type?: BlobPropertyBag,
+): string | undefined {
+  const b =
+    isArrayBuffer(object) || object instanceof Uint8Array
+      ? new Blob(
+          [object instanceof Uint8Array ? new Uint8Array(object) : object],
+          type,
+        )
+      : object;
+  try {
+    return window.URL
+      ? window.URL.createObjectURL(b)
+      : (window as any).webkitURL.createObjectURL(b);
+  } catch (err) {
+    console.warn(`Can not create data url from: ${b}`);
+  }
+}
+
+export function revokeObjectURL(object: string): void {
+  return window.URL
+    ? window.URL.revokeObjectURL(object)
+    : (window as any).webkitURL.revokeObjectURL(object);
+}
+
+function getMobileOperatingSystem(): string {
+  var userAgent =
+    navigator.userAgent || navigator.vendor || (window as any).opera;
+
+  // Windows Phone must come first because its UA also contains "Android"
+  if (/windows phone/i.test(userAgent)) {
+    return "Windows Phone";
+  }
+
+  if (/android/i.test(userAgent)) {
+    return "Android";
+  }
+
+  // iOS detection from: http://stackoverflow.com/a/9039885/177710
+  if (/iPad|iPhone|iPod/.test(userAgent) && !(window as any).MSStream) {
+    return "iOS";
+  }
+
+  return "unknown";
+}
+
+export function detectBrowserIOS(): boolean {
+  return getMobileOperatingSystem() === "iOS";
+}
+
+export function removeKeyFromObject(
+  obj: Record<string, any>,
+  key: string,
+): Record<string, any> {
+  return Object.keys(obj).reduce<Record<string, any>>(
+    (acc, k) =>
+      k === key
+        ? acc
+        : {
+            ...acc,
+            [k]: obj[k],
+          },
+    {},
+  );
+}
+
+export function makeQueryString(obj: Record<string, any>): string {
+  return Object.keys(obj).reduce(
+    (str, key) =>
+      obj[key]
+        ? str.length
+          ? `${str}&${key}=${obj[key]}`
+          : `${key}=${obj[key]}`
+        : str,
+    "",
+  );
+}
+
+export class RequestError extends Error {
+  status: number;
+
+  constructor(message: string, status: number) {
+    super(message);
+    this.status = status;
+  }
+}
+
+export class Debouncer {
+  deferTime: number;
+  timeout: ReturnType<typeof setTimeout> | null;
+
+  constructor(time: number = 100) {
+    this.deferTime = time;
+    this.timeout = null;
+  }
+
+  f(c: () => void): void {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    this.timeout = setTimeout(c, this.deferTime);
+  }
+
+  clear(): void {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+  }
+}
+
+/**
+ * Opens a URL in a new browser window or tab.
+ * In the Readymade desktop app, delegates to the native C++ bridge
+ * (`saucer.exposed.openInBrowser`) because WebKit suppresses window.open()
+ * when the UIDelegate doesn't implement createWebViewWithConfiguration:…
+ * The bridge hands the URL to the OS browser, so a login opened this way finds
+ * the passwords and provider sessions that live there.
+ */
+export function openInBrowser(url: string): void {
+  const saucer = (window as any).saucer;
+  if ((window as any).__MEANDER_CONFIG__ && saucer?.exposed?.openInBrowser) {
+    saucer.exposed.openInBrowser(url);
+  } else {
+    window.open(url, "_blank");
+  }
+}
+
+/**
+ * Where an OAuth provider should send the user back to, for a flow that hands
+ * the login to a browser window this page does not control.
+ *
+ * In the desktop app that is another application, and the webview's own origin
+ * means nothing to it (`saucer://embedded` in release builds), so the callback
+ * goes to the app's loopback HTTP server, which relays the parameters back in.
+ * On the web the page serves /serviceRedirect itself, and the popup posts them
+ * to its opener.
+ *
+ * `webOrigin` overrides the origin used outside the desktop app, for providers
+ * that require a literal loopback address. Whatever this returns must be
+ * registered with the provider as an allowed callback URL. Ask
+ * `canReceiveServiceRedirect` before starting a flow: the address exists even
+ * when nothing here can answer at it.
+ */
+export function serviceRedirectUri(webOrigin?: string): string {
+  const frontendPort = (window as any).__MEANDER_CONFIG__?.frontendPort;
+  if (typeof frontendPort === "number") {
+    return `http://127.0.0.1:${frontendPort}/serviceRedirect`;
+  }
+  return `${webOrigin ?? window.location.origin}/serviceRedirect`;
+}
+
+/**
+ * Whether a callback sent to `serviceRedirectUri` would reach this window.
+ *
+ * False when a second instance of the desktop app is running: the ports are
+ * fixed, so the instance that started first holds the server the callback is
+ * addressed to, and the login completes in that window instead. Worth asking
+ * before handing the user to a browser, because the flow would otherwise wait
+ * for something that has already arrived somewhere else.
+ */
+export function canReceiveServiceRedirect(): boolean {
+  return (window as any).__MEANDER_CONFIG__?.ownsFrontendPort !== false;
+}
+
+export function sleep(t: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, t);
+  });
+}
+
+export function generateUUID(): string {
+  if (
+    typeof crypto !== "undefined" &&
+    typeof crypto.randomUUID === "function"
+  ) {
+    return crypto.randomUUID();
+  }
+
+  if (
+    typeof crypto !== "undefined" &&
+    typeof crypto.getRandomValues === "function"
+  ) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    // RFC 4122 v4 variant bits
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+  }
+
+  // Last-resort fallback for very old/limited environments.
+  return `upload-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}

package/bundle/hkp-frontend/src/runtime/browser/services/http-client-methods.ts

@@ -0,0 +1,10 @@
+/**
+ * The methods `http-client` accepts, in their own module so the service and its
+ * panel can each read them without importing the other.
+ *
+ * Lower case, as every runtime's client stores them, so a board moved between
+ * runtimes keeps the method it was saved with.
+ */
+export const METHODS = ["get", "post", "put", "patch", "delete"] as const;
+
+export type HttpMethod = (typeof METHODS)[number];