@readymadeit/mcp 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,258 @@
+/**
+ * Service Documentation
+ * Service ID: hookup.to/service/configurator
+ * Service Name: Configurator
+ *
+ * Calls configure() on a target service with the incoming params, then either
+ * stops the chain (passThrough: false, default) or passes params downstream
+ * (passThrough: true).
+ *
+ * This is the dedicated routing primitive that replaces the configureServiceUuid
+ * feature in the Map service. Map transforms, Configurator routes.
+ *
+ * Same-runtime:  set targetServiceUuid → resolved via app.getServiceById()
+ * Cross-runtime: also set targetRuntime  → resolved via app.configureServiceInRuntime()
+ *
+ * Optional pipeline: a list of services run in sequence before configure() is
+ * called. Use this to transform the incoming params into whatever shape the
+ * target service's configure() protocol expects — without changing either the
+ * upstream producer or the downstream target.
+ *
+ * State shape:
+ *   {
+ *     targetServiceUuid: string,   // uuid of the service to configure
+ *     targetRuntime?:    string,   // runtime id; omit for same-runtime
+ *     passThrough:       boolean,  // true → continue chain; false → stop (default)
+ *     pipeline: [                  // optional transform pipeline
+ *       { serviceId, instanceId, serviceName?, state? },
+ *       ...
+ *     ]
+ *   }
+ */
+
+import {
+  AppImpl,
+  ProcessContext,
+  ServiceClass,
+  ServiceInstance,
+} from "hkp-frontend/src/types";
+import { nestedRun } from "hkp-frontend/src/runtime/processContext";
+import ServiceBase from "./ServiceBase";
+import BrowserRegistry from "../BrowserRegistry";
+import BrowserRuntimeScope from "../BrowserRuntimeScope";
+import { renameLiveServices, renamedEntries } from "../pipelineNames";
+import { addService, configureService } from "../BrowserRuntimeApi";
+
+const serviceId = "hookup.to/service/configurator";
+const serviceName = "Configurator";
+
+type PipelineEntry = {
+  serviceId: string;
+  instanceId: string;
+  serviceName?: string;
+  state?: Record<string, any>;
+};
+
+type State = {
+  targetServiceUuid: string;
+  targetRuntime?: string;
+  passThrough: boolean;
+  pipeline: PipelineEntry[];
+};
+
+export class Configurator extends ServiceBase<State> {
+  _scope: BrowserRuntimeScope | null = null;
+  private _scopeGeneration = 0;
+  private _scopeBuilding: Promise<void> | null = null;
+
+  constructor(app: AppImpl, board: string, descriptor: ServiceClass, id: string) {
+    super(app, board, descriptor, id, {
+      targetServiceUuid: "",
+      targetRuntime: undefined,
+      passThrough: false,
+      pipeline: [],
+    });
+  }
+
+  configure(config: any): void {
+    if (config.targetServiceUuid !== undefined) {
+      this.state.targetServiceUuid = config.targetServiceUuid;
+    }
+    if (config.targetRuntime !== undefined) {
+      this.state.targetRuntime = config.targetRuntime;
+    }
+    if (config.passThrough !== undefined) {
+      this.state.passThrough = config.passThrough;
+    }
+
+    // A rename arrives as the whole pipeline with one name changed; applied
+    // in place, since rebuilding would restart what the pipeline runs.
+    const renamed = renamedEntries(this.state.pipeline, config.pipeline);
+    if (renamed) {
+      this.state.pipeline = renamed;
+      renameLiveServices(this._scope, renamed);
+      this.app.notify(this as any, { __innerScopeReady: true });
+    } else if (Array.isArray(config.pipeline)) {
+      this.state.pipeline = config.pipeline.map((entry: any) => ({
+        serviceId: entry.serviceId,
+        instanceId: entry.instanceId || entry.uuid || crypto.randomUUID(),
+        ...(entry.serviceName ? { serviceName: entry.serviceName } : {}),
+        ...(entry.state ? { state: entry.state } : {}),
+      }));
+      this._rebuildScope();
+    } else if (config.appendService) {
+      const entry = config.appendService;
+      this.state.pipeline = [
+        ...this.state.pipeline,
+        {
+          serviceId: entry.serviceId,
+          instanceId: entry.instanceId || crypto.randomUUID(),
+          ...(entry.serviceName ? { serviceName: entry.serviceName } : {}),
+          ...(entry.state ? { state: entry.state } : {}),
+        },
+      ];
+      this._rebuildScope();
+    } else if (typeof config.removeService === "string") {
+      this.state.pipeline = this.state.pipeline.filter(
+        (e) => e.instanceId !== config.removeService,
+      );
+      this._rebuildScope();
+    } else if (config.configureService) {
+      const { instanceId, state } = config.configureService;
+      if (this._scope) {
+        const [svc] = this._scope.findServiceInstance(instanceId);
+        if (svc?.configure) {
+          svc.configure(state);
+          Promise.resolve(
+            svc.getConfiguration ? svc.getConfiguration() : (svc as any).state,
+          ).then((updatedState) => {
+            this.state.pipeline = this.state.pipeline.map((e) =>
+              e.instanceId === instanceId ? { ...e, state: updatedState } : e,
+            );
+            this.app.notify(this as any, { __innerScopeReady: true });
+          });
+        }
+      } else {
+        this.state.pipeline = this.state.pipeline.map((e) =>
+          e.instanceId === instanceId ? { ...e, state: { ...e.state, ...state } } : e,
+        );
+      }
+    }
+  }
+
+  getInnerInstance(instanceId: string): ServiceInstance | null {
+    return this._scope?.findServiceInstance(instanceId)[0] ?? null;
+  }
+
+  async process(params: any): Promise<any> {
+    const { targetServiceUuid, targetRuntime, passThrough } = this.state;
+    // Before anything is awaited: the run this call is in is only this call's
+    // until it gives up control.
+    const run = this.app.currentContext?.(this);
+
+    const configured = await this._transform(params, run);
+
+    if (targetServiceUuid && configured !== null) {
+      if (targetRuntime && this.app.configureServiceInRuntime) {
+        await this.app.configureServiceInRuntime(
+          targetRuntime,
+          targetServiceUuid,
+          configured,
+          run,
+        );
+      } else {
+        const target = this.app.getServiceById(targetServiceUuid);
+        if (target) {
+          if (this.app.configureInRun) {
+            await this.app.configureInRun(target, configured, run);
+          } else {
+            await target.configure(configured);
+          }
+        }
+      }
+    }
+
+    return passThrough ? params : null;
+  }
+
+  destroy(): void {
+    this._teardownScope();
+  }
+
+  // -------------------------------------------------------------------------
+
+  /** Run params through the inner pipeline if one is configured. */
+  private async _transform(
+    params: any,
+    run: ProcessContext | undefined,
+  ): Promise<any> {
+    if (this.state.pipeline.length === 0) {
+      return params;
+    }
+    if (!this._scope) {
+      await this._scopeBuilding;
+    }
+    if (!this._scope) {
+      return params;
+    }
+    return this._scope.next(null, params, nestedRun(run), false);
+  }
+
+  private _teardownScope(): void {
+    // Ends what runs inside, not only the reference: see dispose.
+    void this._scope?.dispose();
+    this._scope = null;
+    this._scopeBuilding = null;
+    this._scopeGeneration++;
+  }
+
+  private _rebuildScope(): void {
+    const generation = ++this._scopeGeneration;
+    void this._scope?.dispose();
+    this._scope = null;
+
+    this._scopeBuilding = (async () => {
+      const scope = await this._buildScope();
+      if (generation !== this._scopeGeneration) {
+        void scope.dispose();
+        return;
+      }
+      this._scope = scope;
+      this.app.notify(this as any, { __innerScopeReady: true });
+    })();
+  }
+
+  private async _buildScope(): Promise<BrowserRuntimeScope> {
+    const registry = new BrowserRegistry();
+    const scope = new BrowserRuntimeScope(
+      { id: `configurator-${this.uuid}`, name: "Configurator Pipeline", type: "browser" },
+      registry,
+    );
+    // The board's assets, as the runtime around this pipeline sees them.
+    scope.assets = () => this.app.assets?.() ?? [];
+    // And whoever is signed in to the app around it is signed in here.
+    scope.delegateIdentity(() => this.app.getAuthenticatedUser?.() ?? null);
+
+    for (const entry of this.state.pipeline) {
+      const descriptor = await addService(
+        scope,
+        { serviceId: entry.serviceId, serviceName: entry.serviceName ?? entry.serviceId },
+        entry.instanceId,
+      );
+      if (descriptor && entry.state) {
+        await configureService(scope, descriptor, entry.state);
+      }
+    }
+
+    return scope;
+  }
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (app: AppImpl, board: string, descriptor: ServiceClass, id: string) =>
+    new Configurator(app, board, descriptor, id),
+};
+
+export default descriptor;

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

@@ -0,0 +1,83 @@
+import { useCallback, useState } from "react";
+import { ServiceInstance, ServiceUIProps } from "hkp-frontend/src/types";
+import ServiceUI, {
+  needsUpdate,
+} from "hkp-frontend/src/ui-components/service/ServiceUI";
+import SubServicePipelineUI from "../../ui/SubServicePipelineUI";
+import { findServiceUI } from "../UIRegistry";
+import { Configurator } from "./Configurator";
+import SubmittableInput from "hkp-frontend/src/ui-components/SubmittableInput";
+import Switch from "hkp-frontend/src/ui-components/Switch";
+
+function ConfiguratorUI(props: ServiceUIProps): JSX.Element {
+  const { service } = props;
+
+  const [targetServiceUuid, setTargetServiceUuid] = useState("");
+  const [targetRuntime, setTargetRuntime] = useState("");
+  const [passThrough, setPassThrough] = useState(false);
+  const [, setScopeVersion] = useState(0);
+
+  const updateState = (state: any) => {
+    if (needsUpdate(state.targetServiceUuid, targetServiceUuid)) {
+      setTargetServiceUuid(state.targetServiceUuid ?? "");
+    }
+    if (needsUpdate(state.targetRuntime, targetRuntime)) {
+      setTargetRuntime(state.targetRuntime ?? "");
+    }
+    if (needsUpdate(state.passThrough, passThrough)) {
+      setPassThrough(!!state.passThrough);
+    }
+  };
+
+  const onNotification = useCallback((notification: any) => {
+    if (notification?.__innerScopeReady) {
+      setScopeVersion((v) => v + 1);
+      return;
+    }
+    updateState(notification);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const getActualInstance = useCallback(
+    (instanceId: string): ServiceInstance | null => {
+      const svc = props.service as unknown as Configurator;
+      return svc.getInnerInstance?.(instanceId) ?? null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [props.service],
+  );
+
+  return (
+    <ServiceUI {...props} onNotification={onNotification}>
+      <div className="flex flex-col gap-2 py-1">
+        <SubmittableInput
+          title="Target Service UUID"
+          labelClassName="hkp-svc-field-label"
+          value={targetServiceUuid}
+          placeholder="uuid of target service"
+          onSubmit={(val) => service.configure({ targetServiceUuid: val })}
+        />
+        <SubmittableInput
+          title="Target Runtime"
+          labelClassName="hkp-svc-field-label"
+          value={targetRuntime}
+          placeholder="runtime id (leave empty for same runtime)"
+          onSubmit={(val) => service.configure({ targetRuntime: val })}
+        />
+        <Switch
+          title="Pass Through"
+          labelClassName="hkp-svc-field-label"
+          checked={passThrough}
+          onCheckedChange={(val) => service.configure({ passThrough: val })}
+        />
+      </div>
+      <SubServicePipelineUI
+        service={props.service}
+        findServiceUI={findServiceUI}
+        getActualInstance={getActualInstance}
+      />
+    </ServiceUI>
+  );
+}
+
+export default ConfiguratorUI;

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

@@ -0,0 +1,28 @@
+import HackerUI from "./HackerUI";
+import Hacker from "./Hacker";
+
+import {
+  parseExpression,
+  evalExpression,
+} from "hkp-frontend/src/runtime/browser/services/base/eval";
+
+const serviceId = "hookup.to/service/hacker/considered";
+const serviceName = "Considered Hacker";
+
+class ConsideredHacker extends Hacker {
+  process(params: any): any {
+    return this.baseProcess((buffer: string) =>
+      evalExpression(parseExpression(buffer), { params }, this.app, this),
+    );
+  }
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (app: any, board: any, descriptor: any, id: string) =>
+    new ConsideredHacker(app, board, descriptor, id),
+  createUI: HackerUI,
+};
+
+export default descriptor;

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

@@ -0,0 +1,75 @@
+import { AppInstance, ServiceClass } from "hkp-frontend/src/types";
+import DebounceUI from "./DebounceUI";
+
+const serviceId = "hookup.to/service/debounce";
+const serviceName = "Debounce";
+
+class Debounce {
+  uuid: string;
+  board: string;
+  app: AppInstance;
+
+  cooldown: number; // seconds
+  lastFired: number | null;
+
+  constructor(
+    app: AppInstance,
+    board: string,
+    _descriptor: ServiceClass,
+    id: string,
+  ) {
+    this.uuid = id;
+    this.board = board;
+    this.app = app;
+    this.cooldown = 60;
+    this.lastFired = null;
+  }
+
+  configure(config: any): void {
+    const { cooldown, reset } = config;
+
+    if (cooldown !== undefined) {
+      this.cooldown = cooldown;
+      this.app.notify(this, { cooldown });
+    }
+
+    if (reset) {
+      this.lastFired = null;
+      this.app.notify(this, { lastFired: null, remaining: null });
+    }
+  }
+
+  getConfiguration() {
+    return Promise.resolve({ cooldown: this.cooldown, lastFired: this.lastFired });
+  }
+
+  process(params: any): any {
+    const now = Date.now();
+    const elapsed =
+      this.lastFired !== null ? (now - this.lastFired) / 1000 : Infinity;
+
+    if (elapsed >= this.cooldown) {
+      this.lastFired = now;
+      this.app.notify(this, { lastFired: now, remaining: null });
+      return params;
+    }
+
+    const remaining = Math.ceil(this.cooldown - elapsed);
+    this.app.notify(this, { remaining });
+    return null;
+  }
+}
+
+export default {
+  serviceName,
+  serviceId,
+  create(
+    app: AppInstance,
+    board: string,
+    descriptor: ServiceClass,
+    id: string,
+  ) {
+    return new Debounce(app, board, descriptor, id);
+  },
+  createUI: DebounceUI,
+};

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

@@ -0,0 +1,70 @@
+import { useState } from "react";
+
+import { ServiceUIProps } from "hkp-frontend/src/types";
+import ServiceUI, {
+  needsUpdate,
+} from "hkp-frontend/src/ui-components/service/ServiceUI";
+import { Button } from "hkp-frontend/src/ui-components/primitives/button";
+import Slider from "hkp-frontend/src/ui-components/Slider";
+
+export default function DebounceUI(props: ServiceUIProps) {
+  const { service } = props;
+
+  const [cooldown, setCooldown] = useState(60);
+  const [lastFired, setLastFired] = useState<number | null>(null);
+  const [remaining, setRemaining] = useState<number | null>(null);
+
+  const update = (state: any) => {
+    if (needsUpdate(state.cooldown, cooldown)) {
+      setCooldown(state.cooldown);
+    }
+    if (state.lastFired !== undefined) {
+      setLastFired(state.lastFired);
+      if (state.remaining === null) {
+        setRemaining(null);
+      }
+    }
+    if (state.remaining !== undefined) {
+      setRemaining(state.remaining);
+    }
+  };
+
+  const lastFiredDisplay = lastFired
+    ? new Date(lastFired).toLocaleTimeString()
+    : "never";
+
+  return (
+    <ServiceUI
+      {...props}
+      className="py-2"
+      initialSize={{ width: 278, height: 155 }}
+      service={service}
+      onInit={update}
+      onNotification={update}
+    >
+      <div className="flex flex-col gap-3 h-full">
+        <Slider
+          title="Cooldown (s)"
+          value={cooldown}
+          min={1}
+          max={3600}
+          onChange={(v: number) => {
+            setCooldown(v);
+            service.configure({ cooldown: v });
+          }}
+        />
+        <div className="flex justify-between text-xs text-muted-foreground">
+          <span>Last fired: {lastFiredDisplay}</span>
+          {remaining !== null && <span>Ready in: {remaining}s</span>}
+        </div>
+        <Button
+          className="hkp-svc-btn"
+          variant="outline"
+          onClick={() => service.configure({ reset: true })}
+        >
+          Reset Cooldown
+        </Button>
+      </div>
+    </ServiceUI>
+  );
+}

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

@@ -0,0 +1,127 @@
+import { AppInstance, ServiceClass } from "hkp-frontend/src/types";
+import ServiceBase from "./ServiceBase";
+import {
+  THIS_DEVICE,
+  resolveCredential,
+} from "hkp-frontend/src/core/secrets";
+import DecryptUI from "./DecryptUI";
+
+/**
+ * Service Documentation
+ * Service ID: hookup.to/service/decrypt
+ * Service Name: Decrypt
+ * Input:  base64 string — [12-byte IV][AES-256-GCM ciphertext] (produced by Encrypt)
+ * Output: original value — JSON-deserialised object/string/number, or Blob
+ * Config: secret (string), method ("aes")
+ *
+ * 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/decrypt";
+const serviceName = "Decrypt";
+
+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 base64ToBlob(base64: string): Promise<Blob> {
+  const dataUrl = "data:application/octet-stream;base64," + base64;
+  const resp = await fetch(dataUrl);
+  return resp.blob();
+}
+
+class Decrypt 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<any> {
+    if (!this.state.secret) {
+      this.pushErrorNotification("Decrypt: no secret configured");
+      return null;
+    }
+
+    if (typeof params !== "string") {
+      this.pushErrorNotification("Decrypt: expected a base64-encoded string");
+      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(`Decrypt: ${problem}`);
+      return null;
+    }
+
+    try {
+      const combined = Uint8Array.from(atob(params), (c) => c.charCodeAt(0));
+      const iv = combined.slice(0, 12);
+      const ciphertext = combined.slice(12);
+
+      const key = await deriveKey(secret, "decrypt");
+      const plaintextBytes = await crypto.subtle.decrypt(
+        { name: "AES-GCM", iv },
+        key,
+        ciphertext,
+      );
+
+      const plaintext = new TextDecoder().decode(plaintextBytes);
+      const parsed = JSON.parse(plaintext);
+
+      // Reconstruct Blob if the original input was one
+      if (parsed && typeof parsed === "object" && "__blob" in parsed) {
+        return base64ToBlob(parsed.__blob);
+      }
+
+      return parsed;
+    } catch {
+      this.pushErrorNotification("Decrypt: decryption failed — wrong key?");
+      return null;
+    }
+  }
+}
+
+const descriptor = {
+  serviceName,
+  serviceId,
+  create: (app: AppInstance, board: string, descriptor: ServiceClass, id: string) =>
+    new Decrypt(app, board, descriptor, id),
+  createUI: DecryptUI,
+};
+
+export default descriptor;

package/bundle/hkp-frontend/src/runtime/browser/services/DecryptUI.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 DecryptUI(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>
+  );
+}