@ai-matrx/applets 0.2.7

package/dist/host.js

@@ -0,0 +1,641 @@
+// src/types.ts
+var PAGE_ACTION_STREAM = "actions";
+var NAV_STREAM = "nav";
+var runStream = (requestId) => `run:${requestId}`;
+var valueStream = (name) => `value:${name}`;
+function ok(data) {
+  return { ok: true, data };
+}
+function fail(code, message, retryable = false, diagnostic) {
+  const error = { code, message, retryable };
+  if (diagnostic !== void 0) error.diagnostic = diagnostic;
+  return { ok: false, error };
+}
+function toAppletError(err, code = "internal") {
+  if (err && typeof err === "object") {
+    const o = err;
+    if (typeof o.code === "string" && typeof o.message === "string") {
+      const out = { code: o.code, message: o.message, retryable: o.retryable === true };
+      if (typeof o.diagnostic === "string") out.diagnostic = o.diagnostic;
+      return out;
+    }
+    if (err instanceof Error) return { code, message: err.message, retryable: false };
+  }
+  return { code, message: String(err), retryable: false };
+}
+
+// src/host/memory.ts
+var CHAIN = /* @__PURE__ */ Symbol("applets.memory.chain");
+var SURFACE_NAME = /* @__PURE__ */ Symbol("applets.memory.surfaceName");
+function mintId(world, prefix) {
+  world.nextId += 1;
+  return `${prefix}-${world.nextId.toString(36).padStart(4, "0")}`;
+}
+function parsePath(to) {
+  const [pathPart = "", queryPart = ""] = to.split("?");
+  const path = pathPart.split("/").filter(Boolean);
+  const params = {};
+  for (const pair of queryPart.split("&").filter(Boolean)) {
+    const [k = "", v = ""] = pair.split("=");
+    params[decodeURIComponent(k)] = decodeURIComponent(v);
+  }
+  return { path, params };
+}
+var clone = (value) => value === void 0 ? value : JSON.parse(JSON.stringify(value));
+function matches(row, q) {
+  for (const w of q.where ?? []) {
+    const v = row[w.column];
+    switch (w.op) {
+      case "eq":
+        if (v !== w.value) return false;
+        break;
+      case "neq":
+        if (v === w.value) return false;
+        break;
+      case "lt":
+        if (!(v < w.value)) return false;
+        break;
+      case "lte":
+        if (!(v <= w.value)) return false;
+        break;
+      case "gt":
+        if (!(v > w.value)) return false;
+        break;
+      case "gte":
+        if (!(v >= w.value)) return false;
+        break;
+      case "contains":
+        if (!String(v ?? "").toLowerCase().includes(String(w.value ?? "").toLowerCase())) return false;
+        break;
+      case "in":
+        if (!Array.isArray(w.value) || !w.value.includes(v)) return false;
+        break;
+      case "empty":
+        if (!(v === null || v === void 0 || v === "")) return false;
+        break;
+    }
+  }
+  if (q.search) {
+    const needle = q.search.toLowerCase();
+    const hit = Object.entries(row).some(([k, v]) => !k.startsWith("_") && typeof v === "string" && v.toLowerCase().includes(needle));
+    if (!hit) return false;
+  }
+  return true;
+}
+function compare(a, b) {
+  if (a === b) return 0;
+  if (a === null || a === void 0) return 1;
+  if (b === null || b === void 0) return -1;
+  return a < b ? -1 : 1;
+}
+function createMemoryHost(spec) {
+  const world = {
+    hosts: /* @__PURE__ */ new Map(),
+    location: parsePath(spec.path ?? "/"),
+    nextId: 0,
+    calls: [],
+    errors: [],
+    latencyMs: spec.latencyMs ?? 0,
+    pendingActions: /* @__PURE__ */ new Map()
+  };
+  return buildHost(world, spec, "memory:root", null);
+}
+function buildHost(world, spec, hostId, parent) {
+  const record = spec.record;
+  const listeners = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const tables = /* @__PURE__ */ new Map();
+  const values = new Map(Object.entries(spec.surface?.values ?? {}));
+  const runs = /* @__PURE__ */ new Map();
+  let mounted = null;
+  for (const [alias, t] of Object.entries(spec.tables ?? {})) {
+    const rows = (t.rows ?? []).map((values2) => ({
+      archived: false,
+      row: {
+        ...clone(values2),
+        _id: typeof values2._id === "string" ? values2._id : mintId(world, "row"),
+        _version: typeof values2._version === "number" ? values2._version : 1,
+        _organization_id: t.organizationId ?? record.organizationId
+      }
+    }));
+    tables.set(alias, { spec: t, rows });
+  }
+  const wait = () => new Promise((resolve) => setTimeout(resolve, world.latencyMs));
+  const log = (port, method, args) => {
+    world.calls.push({ hostId, port, method, args: clone(args) });
+  };
+  const emit = (stream, payload) => {
+    for (const [subscriptionId, s] of subscriptions) {
+      if (s !== stream) continue;
+      const message = { subscriptionId, payload: clone(payload) };
+      for (const l of listeners) l(message);
+    }
+  };
+  const refuse = (code, message, diagnostic) => ({
+    ok: false,
+    error: diagnostic === void 0 ? { code, message } : { code, message, diagnostic }
+  });
+  const answer = (data2) => ({ ok: true, data: data2 });
+  const table = (alias) => {
+    const t = tables.get(alias);
+    if (!t) return refuse("not_found", `This Applet declares no source named "${alias}".`);
+    return answer(t);
+  };
+  const dataListeners = /* @__PURE__ */ new Map();
+  const bump = (alias, event) => {
+    setTimeout(() => {
+      for (const l of [...dataListeners.get(`rows:${alias}`) ?? []]) l(clone(event));
+    }, 0);
+  };
+  const findRow = (rows, id) => rows.find((r) => r.row._id === id);
+  const memoryData = {
+    subscribe(event, listener) {
+      let set = dataListeners.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        dataListeners.set(event, set);
+      }
+      set.add(listener);
+      const held = set;
+      return () => {
+        held.delete(listener);
+      };
+    },
+    async sources() {
+      log("data", "sources", []);
+      await wait();
+      const out = [...tables.entries()].map(([alias, t]) => ({
+        alias,
+        label: t.spec.label ?? alias,
+        kind: t.spec.kind ?? "table",
+        canCreate: t.spec.canCreate ?? true,
+        canUpdate: t.spec.canUpdate ?? true
+      }));
+      return answer(out);
+    },
+    async columns(alias) {
+      log("data", "columns", [alias]);
+      await wait();
+      const t = table(alias);
+      return t.ok ? answer(clone(t.data.spec.columns)) : t;
+    },
+    async list(alias, q, cursor) {
+      log("data", "list", [alias, q, cursor]);
+      await wait();
+      const t = table(alias);
+      if (!t.ok) return t;
+      let rows = t.data.rows.filter((r) => !r.archived).map((r) => r.row).filter((r) => matches(r, q));
+      for (const s of [...q.sort ?? []].reverse()) {
+        const dir = s.direction === "desc" ? -1 : 1;
+        rows = [...rows].sort((a, b) => dir * compare(a[s.column], b[s.column]));
+      }
+      const start = cursor ? rows.findIndex((r) => r._id === cursor) + 1 : 0;
+      if (cursor && start === 0) return refuse("invalid_argument", "That page cursor is not from this list.");
+      const size = q.pageSize ?? 50;
+      const page = rows.slice(start, start + size);
+      const last = page[page.length - 1];
+      return answer({ rows: clone(page), total: rows.length, cursor: start + size < rows.length && last ? last._id : null });
+    },
+    async get(alias, id) {
+      log("data", "get", [alias, id]);
+      await wait();
+      const t = table(alias);
+      if (!t.ok) return t;
+      const r = findRow(t.data.rows, id);
+      return answer(r && !r.archived ? clone(r.row) : null);
+    },
+    async create(alias, values2) {
+      log("data", "create", [alias, values2]);
+      await wait();
+      const t = table(alias);
+      if (!t.ok) return t;
+      if (t.data.spec.canCreate === false) return refuse("door", `New records cannot be added to ${t.data.spec.label ?? alias} here.`);
+      const refusal = t.data.spec.refuse?.({ op: "create", values: values2 });
+      if (refusal) return { ok: false, error: refusal };
+      const row = {
+        ...clone(values2),
+        _id: mintId(world, "row"),
+        _version: 1,
+        _organization_id: t.data.spec.organizationId ?? record.organizationId
+      };
+      t.data.rows.unshift({ row, archived: false });
+      bump(alias, { ids: [row._id] });
+      return answer(clone(row));
+    },
+    async update(alias, id, patch, baseVersion) {
+      log("data", "update", [alias, id, patch, baseVersion]);
+      await wait();
+      const t = table(alias);
+      if (!t.ok) return t;
+      if (t.data.spec.canUpdate === false) return refuse("door", `${t.data.spec.label ?? alias} is read-only here.`);
+      const stored = findRow(t.data.rows, id);
+      if (!stored || stored.archived) return refuse("not_found", "This record is not here any more.");
+      if (stored.row._version !== baseVersion) {
+        return refuse(
+          "stale_write",
+          "Someone else changed this record after you opened it. Your change was not saved.",
+          `base ${baseVersion}, current ${stored.row._version}`
+        );
+      }
+      const refusal = t.data.spec.refuse?.({ op: "update", id, patch, baseVersion });
+      if (refusal) return { ok: false, error: refusal };
+      stored.row = { ...stored.row, ...clone(patch), _id: id, _version: stored.row._version + 1 };
+      bump(alias, { ids: [id] });
+      return answer(clone(stored.row));
+    },
+    async archive(alias, id) {
+      log("data", "archive", [alias, id]);
+      await wait();
+      const t = table(alias);
+      if (!t.ok) return t;
+      const stored = findRow(t.data.rows, id);
+      if (!stored) return refuse("not_found", "This record is not here any more.");
+      const refusal = t.data.spec.refuse?.({ op: "archive", id });
+      if (refusal) return { ok: false, error: refusal };
+      stored.archived = true;
+      stored.row = { ...stored.row, _version: stored.row._version + 1 };
+      bump(alias, { ids: [id] });
+      return answer(void 0);
+    },
+    async restore(alias, id) {
+      log("data", "restore", [alias, id]);
+      await wait();
+      const t = table(alias);
+      if (!t.ok) return t;
+      const stored = findRow(t.data.rows, id);
+      if (!stored) return refuse("not_found", "This record is not here any more.");
+      const refusal = t.data.spec.refuse?.({ op: "restore", id });
+      if (refusal) return { ok: false, error: refusal };
+      stored.archived = false;
+      stored.row = { ...stored.row, _version: stored.row._version + 1 };
+      bump(alias, { ids: [id] });
+      return answer(void 0);
+    }
+  };
+  const dataPort = spec.data ?? memoryData;
+  const data = {
+    sources: () => dataPort.sources(),
+    columns: (alias) => dataPort.columns(alias),
+    list: (alias, q, cursor) => dataPort.list(alias, q, cursor),
+    get: (alias, id) => dataPort.get(alias, id),
+    create: (alias, values2) => dataPort.create(alias, values2),
+    update: (alias, id, patch, baseVersion) => dataPort.update(alias, id, patch, baseVersion),
+    archive: (alias, id) => dataPort.archive(alias, id),
+    restore: (alias, id) => dataPort.restore(alias, id)
+  };
+  const rowsUnsubscribe = /* @__PURE__ */ new Map();
+  const playRun = (requestId) => {
+    const run = runs.get(requestId);
+    if (!run) return;
+    const step = () => {
+      const event = run.rest.shift();
+      if (!event) {
+        if (run.status === "running") {
+          run.status = "done";
+          emit(runStream(requestId), { type: "status", status: "done" });
+        }
+        return;
+      }
+      if (event.type === "text") run.text += event.delta;
+      if (event.type === "status") run.status = event.status;
+      if (event.type === "result") {
+        run.envelope = event;
+        run.status = "done";
+      }
+      if (event.type === "error") run.status = "error";
+      if (event.type === "needs_input") run.status = "needs_input";
+      emit(runStream(requestId), event);
+      if (event.type === "needs_input" || event.type === "result" || event.type === "error") return;
+      setTimeout(step, 0);
+    };
+    setTimeout(step, world.latencyMs);
+  };
+  const intelligence = {
+    async describe(key) {
+      log("intelligence", "describe", [key]);
+      await wait();
+      const m = spec.mandates?.[key];
+      if (!m) return fail("mandate_not_found", `No job named "${key}" exists.`);
+      return ok({
+        key,
+        label: m.label,
+        goal: m.goal,
+        outputKind: m.outputKind ?? null,
+        inputs: clone(m.inputs ?? []),
+        holder: { type: m.holder ?? "agent" }
+      });
+    },
+    async run(req) {
+      log("intelligence", "run", [req]);
+      await wait();
+      const m = spec.mandates?.[req.key];
+      if (!m) return fail("mandate_not_found", `No job named "${req.key}" exists.`);
+      const requestId = mintId(world, "req");
+      const ref = { requestId, conversationId: mintId(world, "conv"), mandateKey: req.key };
+      const runReq = { variables: clone(req.variables ?? {}) };
+      if (req.userInput !== void 0) runReq.userInput = req.userInput;
+      runs.set(requestId, {
+        ref,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "running",
+        text: "",
+        envelope: null,
+        rest: m.script(runReq),
+        req: runReq,
+        key: req.key
+      });
+      playRun(requestId);
+      return ok(ref);
+    },
+    async result(ref) {
+      log("intelligence", "result", [ref]);
+      await wait();
+      const run = runs.get(ref.requestId);
+      if (!run) return fail("run_not_found", "That run is not here.");
+      const envelope = run.envelope && run.envelope.type === "result" ? run.envelope.envelope : null;
+      return ok({ envelope: clone(envelope), text: run.text, status: run.status });
+    },
+    async answer(ref, answers) {
+      log("intelligence", "answer", [ref, answers]);
+      await wait();
+      const run = runs.get(ref.requestId);
+      if (!run) return fail("run_not_found", "That run is not here.");
+      if (run.status !== "needs_input") return fail("not_waiting", "This run is not waiting for an answer.");
+      const m = spec.mandates?.[run.key];
+      if (m?.afterAnswer) run.rest = m.afterAnswer(run.req, clone(answers));
+      run.status = "running";
+      playRun(ref.requestId);
+      return ok(void 0);
+    },
+    async rejoin(ref) {
+      log("intelligence", "rejoin", [ref]);
+      await wait();
+      return runs.has(ref.requestId) ? ok(void 0) : fail("run_not_found", "That run is not here.");
+    },
+    async listRuns(key) {
+      log("intelligence", "listRuns", [key]);
+      await wait();
+      const out = [...runs.values()].filter((r) => r.key === key).map((r) => ({ ref: clone(r.ref), startedAt: r.startedAt, status: r.status })).reverse();
+      return ok(out);
+    },
+    async createSoft(s) {
+      log("intelligence", "createSoft", [s]);
+      await wait();
+      if (spec.mandates?.[s.key]) return fail("already_exists", `A job named "${s.key}" already exists.`);
+      spec.mandates = {
+        ...spec.mandates ?? {},
+        [s.key]: { label: s.label, goal: s.goal, outputKind: s.outputKind ?? null, script: () => [] }
+      };
+      return ok({ key: s.key });
+    }
+  };
+  const ownActions = () => spec.surface?.actions ?? [];
+  const toInfo = (a, declaredOn) => {
+    const info = {
+      name: a.name,
+      category: a.category ?? "applet",
+      label: a.label,
+      description: a.description,
+      runs: a.runs,
+      policy: a.policy,
+      triggeredBy: [...a.triggeredBy],
+      declaredOn
+    };
+    if (a.input !== void 0) info.input = a.input;
+    if (a.output !== void 0) info.output = a.output;
+    if (a.target !== void 0) info.target = a.target;
+    if (a.updatesValue !== void 0) info.updatesValue = a.updatesValue;
+    return info;
+  };
+  const chain = () => {
+    const out = /* @__PURE__ */ new Map();
+    for (const d of ownActions()) out.set(d.name, { decl: d, owner: self });
+    if (parent) {
+      for (const link of parent[CHAIN]()) if (!out.has(link.decl.name)) out.set(link.decl.name, link);
+    }
+    return [...out.values()];
+  };
+  const surface = {
+    async mount(name, parentName) {
+      log("surface", "mount", [name, parentName]);
+      await wait();
+      mounted = { mountId: mintId(world, "mount"), name, parent: parentName };
+      return ok({ mountId: mounted.mountId });
+    },
+    async unmount(mountId) {
+      log("surface", "unmount", [mountId]);
+      if (mounted?.mountId === mountId) mounted = null;
+    },
+    async getValue(name) {
+      log("surface", "getValue", [name]);
+      await wait();
+      return clone(values.get(name));
+    },
+    async setValue(name, v) {
+      log("surface", "setValue", [name, v]);
+      await wait();
+      values.set(name, clone(v));
+      emit(valueStream(name), v);
+    },
+    async listActions() {
+      log("surface", "listActions", []);
+      await wait();
+      return chain().map((l) => toInfo(l.decl, l.owner[SURFACE_NAME]));
+    },
+    async runAction(name, input, by) {
+      log("surface", "runAction", [name, input, by]);
+      await wait();
+      const link = chain().find((l) => l.decl.name === name);
+      if (!link) return fail("action_not_found", `This page has no action named "${name}".`);
+      const { decl, owner } = link;
+      if (!decl.triggeredBy.includes(by)) {
+        return fail("caller_refused", `"${decl.label}" cannot be started by ${by === "person" ? "a person" : `an ${by}`}.`);
+      }
+      if (decl.policy === "manual" && by !== "person") {
+        return fail("caller_refused", `Only a person can start "${decl.label}".`);
+      }
+      const viewer = await self.viewer();
+      const runId = mintId(world, "act");
+      let result;
+      switch (decl.runs) {
+        case "page": {
+          result = await new Promise((resolve) => {
+            world.pendingActions.set(runId, resolve);
+            const event = { action: name, input, runId, by };
+            owner.control.emit(PAGE_ACTION_STREAM, event);
+          });
+          break;
+        }
+        case "server": {
+          const handler = spec.surface?.serverActions?.[decl.target ?? name];
+          if (!handler) {
+            result = fail("not_supported", `The server action "${decl.target ?? name}" is not available here.`);
+            break;
+          }
+          try {
+            result = ok(await handler(input, { runId, by, viewerId: viewer.userId }));
+          } catch (err) {
+            result = { ok: false, error: toAppletError(err) };
+          }
+          break;
+        }
+        case "mandate": {
+          const key = record.mandates.find((m) => m.alias === decl.target)?.key ?? decl.target ?? "";
+          const variables = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+          result = await intelligence.run({ key, variables, organizationId: viewer.activeOrganizationId, appletId: record.id, surfaceName: record.surfaceName });
+          break;
+        }
+        case "navigate": {
+          const params = input && typeof input === "object" ? input : {};
+          const to = (decl.target ?? "/").replace(/\{(\w+)\}/g, (_m, k) => encodeURIComponent(String(params[k] ?? "")));
+          await nav.go(to);
+          result = ok(to);
+          break;
+        }
+      }
+      if (result.ok && decl.updatesValue) await surface.setValue(decl.updatesValue, result.data);
+      return result;
+    },
+    async completeAction(runId, result) {
+      log("surface", "completeAction", [runId, result]);
+      const resolve = world.pendingActions.get(runId);
+      world.pendingActions.delete(runId);
+      resolve?.(result);
+    }
+  };
+  const nav = {
+    async go(to) {
+      log("nav", "go", [to]);
+      world.location = parsePath(to);
+      for (const h of world.hosts.values()) h.control.emit(NAV_STREAM, world.location);
+    },
+    async current() {
+      log("nav", "current", []);
+      return clone(world.location);
+    }
+  };
+  let childCount = 0;
+  const self = {
+    kind: "memory",
+    hostId,
+    [CHAIN]: chain,
+    [SURFACE_NAME]: record.surfaceName,
+    async viewer() {
+      log("host", "viewer", []);
+      return {
+        userId: spec.viewer?.userId ?? "memory-viewer",
+        organizationIds: spec.viewer?.organizationIds ?? [record.organizationId],
+        activeOrganizationId: spec.viewer?.activeOrganizationId ?? record.organizationId,
+        guest: spec.viewer?.guest ?? false
+      };
+    },
+    async record() {
+      log("host", "record", []);
+      await wait();
+      return clone(record);
+    },
+    async child(appletId) {
+      log("host", "child", [appletId]);
+      await wait();
+      const childSpec = spec.children?.[appletId];
+      if (!childSpec) throw new Error(`[applets/memory] no child Applet "${appletId}" in this memory host's spec.`);
+      childCount += 1;
+      const childId = `${hostId}/${appletId}#${childCount}`;
+      buildHost(world, { latencyMs: world.latencyMs, ...childSpec }, childId, self);
+      return { hostId: childId };
+    },
+    kinds: {
+      async definition(slug) {
+        log("kinds", "definition", [slug]);
+        const k = spec.kinds?.[slug];
+        return k?.definition !== void 0 ? ok(clone(k.definition)) : fail("kind_not_found", `No kind named "${slug}".`);
+      },
+      async component(slug, platform) {
+        log("kinds", "component", [slug, platform]);
+        return ok(clone(spec.kinds?.[slug]?.component ?? null));
+      }
+    },
+    pages: {
+      async definition(pageId) {
+        log("pages", "definition", [pageId]);
+        const p = spec.dataPages?.[pageId];
+        return p !== void 0 ? ok(clone(p)) : fail("page_not_found", "That page is not here.");
+      }
+    },
+    data,
+    intelligence,
+    surface,
+    nav,
+    events: {
+      async on(stream, filter) {
+        log("events", "on", [stream, filter]);
+        const subscriptionId = mintId(world, "sub");
+        subscriptions.set(subscriptionId, stream);
+        if (stream.startsWith("rows:")) {
+          const stop = dataPort.subscribe(stream, (event) => {
+            const message = { subscriptionId, payload: clone(event) };
+            for (const l of listeners) l(message);
+          });
+          rowsUnsubscribe.set(subscriptionId, stop);
+        }
+        return { subscriptionId };
+      },
+      async off(subscriptionId) {
+        log("events", "off", [subscriptionId]);
+        subscriptions.delete(subscriptionId);
+        rowsUnsubscribe.get(subscriptionId)?.();
+        rowsUnsubscribe.delete(subscriptionId);
+      }
+    },
+    async reportError(err) {
+      log("host", "reportError", [err]);
+      world.errors.push(clone(err));
+    },
+    receive(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    forHost(id) {
+      return world.hosts.get(id) ?? null;
+    },
+    control: {
+      dataPort,
+      get calls() {
+        return world.calls;
+      },
+      get errors() {
+        return world.errors;
+      },
+      rows(alias) {
+        return (tables.get(alias)?.rows ?? []).map((r) => ({ ...clone(r.row), ...r.archived ? { _archived: true } : {} }));
+      },
+      externalUpdate(alias, id, patch) {
+        const stored = findRow(tables.get(alias)?.rows ?? [], id);
+        if (!stored) throw new Error(`[applets/memory] no row ${id} in ${alias}`);
+        stored.row = { ...stored.row, ...clone(patch), _version: stored.row._version + 1 };
+        bump(alias, { ids: [id] });
+        return clone(stored.row);
+      },
+      externalCreate(alias, values2) {
+        const t = tables.get(alias);
+        if (!t) throw new Error(`[applets/memory] no table ${alias}`);
+        const row = { ...clone(values2), _id: mintId(world, "row"), _version: 1, _organization_id: t.spec.organizationId ?? record.organizationId };
+        t.rows.unshift({ row, archived: false });
+        bump(alias, { ids: [row._id] });
+        return clone(row);
+      },
+      emit,
+      location() {
+        return clone(world.location);
+      }
+    }
+  };
+  world.hosts.set(hostId, self);
+  return self;
+}
+export {
+  createMemoryHost
+};
+//# sourceMappingURL=host.js.map