aimeat 1.40.1 → 2.1.0

package/dist/static/sdk-libs/webmcp/index.js

@@ -0,0 +1,185 @@
+/**
+ * @file webmcp/index.js
+ * @description The aimeat-webmcp library (SDK-libs migration Phase 2, TARGET-034 phase C). The in-page
+ *   half of the WebMCP bridge: feature-detects every shipped shape of the WebMCP registration API
+ *   (document.modelContext.registerTool — current CG draft; navigator.modelContext.registerTool /
+ *   provideContext — transitional), registers an app's declared tools (apps.{appId}.tools) with real
+ *   execute callbacks, and exposes node-level tools. Priced tools pay through AIMEAT.commerce.
+ *   invokeAppTool when signed in; otherwise execute returns the 402/x402 payment instructions.
+ *   Componentized ESM source esbuild bundles to the IIFE served, unchanged, at /v1/libs/aimeat-webmcp.js.
+ *   Ported verbatim from lib-webmcp.ts; NODE_URL is the apex base (APEX_URL from _core/config).
+ * @structure imports APEX_URL (config) + attach (namespace); asContent/registerWith/fetchListing/
+ *   buildExecute; the `webmcp` object; attach('webmcp', …) + optional ?expose=node auto-activation.
+ * @usage <script src="/v1/libs/aimeat-webmcp.js"></script>
+ *   await AIMEAT.webmcp.exposeAppTools({ owner: 'alice', appId: 'shop.html' });
+ * @version-history
+ *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-webmcp.ts (SDK-libs migration Phase 2).
+ */
+import { APEX_URL } from '../_core/config.js';
+import { attach } from '../_core/namespace.js';
+
+const NODE_URL = APEX_URL;
+
+/** Wrap any value as WebMCP tool-result content ({ content: [{ type:'text', text }] }). */
+function asContent(value) {
+  const text = typeof value === 'string' ? value : JSON.stringify(value, null, 1);
+  return { content: [{ type: 'text', text: text }] };
+}
+
+/**
+ * Feature-detect the WebMCP registration surface:
+ *  - document.modelContext.registerTool  (current CG draft)
+ *  - navigator.modelContext.registerTool (transitional)
+ *  - navigator.modelContext.provideContext({ tools }) (earlier explainer shape; readiness
+ *    scanners shim this and watch for the call)
+ * Returns which surface took the tools, or 'none' when no agent/scanner API is present.
+ */
+async function registerWith(tools) {
+  // modelContext is a non-standard (WebMCP draft) API absent from lib.dom — access via any.
+  const doc = /** @type {any} */ (typeof document !== 'undefined' ? document : {});
+  const nav = /** @type {any} */ (typeof navigator !== 'undefined' ? navigator : {});
+  const docMc = doc.modelContext;
+  const navMc = nav.modelContext;
+  if (docMc && typeof docMc.registerTool === 'function') {
+    for (const t of tools) await docMc.registerTool(t);
+    return 'document.modelContext.registerTool';
+  }
+  if (navMc && typeof navMc.registerTool === 'function') {
+    for (const t of tools) await navMc.registerTool(t);
+    return 'navigator.modelContext.registerTool';
+  }
+  if (navMc && typeof navMc.provideContext === 'function') {
+    // provideContext replaces the full tool set — pass everything registered so far.
+    await navMc.provideContext({ tools: webmcp.tools.concat(tools) });
+    return 'navigator.modelContext.provideContext';
+  }
+  return 'none';
+}
+
+/** Fetch an app's served WebMCP listing (public manifest view). */
+async function fetchListing(owner, appId) {
+  const r = await fetch(NODE_URL + '/v1/apps/' + encodeURIComponent(owner) + '/' + encodeURIComponent(appId) + '/webmcp');
+  const body = await r.json();
+  if (!r.ok) throw new Error((body.error && body.error.message) || ('WebMCP listing failed: ' + r.status));
+  return body;
+}
+
+/** Build the execute() for one app tool: paid → checkout; free-callable → HTTP invoke. */
+function buildExecute(owner, appId, entry) {
+  return async function execute(args) {
+    const appRef = owner + '/' + appId;
+    const paid = entry.payment && entry.payment.required;
+    if (paid) {
+      const commerce = window.AIMEAT && window.AIMEAT.commerce;
+      const session = window.AIMEAT && window.AIMEAT.auth && window.AIMEAT.auth.getSession && window.AIMEAT.auth.getSession();
+      if (commerce && session) {
+        // Signed in: pay through the checkout core. A callable tool's result rides on the
+        // completed session; a task tool returns the queued task id.
+        try {
+          const done = await commerce.invokeAppTool({ app: appRef, tool: entry.name, input: args || {} });
+          const f = done.fulfillment || {};
+          const result = (f.results && f.results[0] && f.results[0].result !== undefined)
+            ? f.results[0].result
+            : { queued_task: (f.taskIds && f.taskIds[0]) || null, note: 'Order queued as an agent task; the deliverable arrives via the seller.' };
+          return asContent({ tool: entry.name, receipt: done.receipt, result: result });
+        } catch (e) {
+          return asContent({ tool: entry.name, error: e.message, code: e.code, accepts: e.accepts });
+        }
+      }
+      // Signed out (or commerce lib absent): surface the 402 payment instructions verbatim so
+      // the agent learns HOW to pay (x402-style accepts + ready-made checkout line item).
+      const r = await fetch(entry.invoke.url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ input: args || {} }) });
+      return asContent(await r.json());
+    }
+    // Unpriced: direct HTTP invoke (needs a signed-in session for the bearer token).
+    const sess = window.AIMEAT && window.AIMEAT.auth && window.AIMEAT.auth.getSession && window.AIMEAT.auth.getSession();
+    if (!sess) return asContent({ tool: entry.name, error: 'Sign in to call this free tool (bearer token required).' });
+    const res = await sess.fetch('/v1/apps/' + encodeURIComponent(owner) + '/' + encodeURIComponent(appId) + '/webmcp/tools/' + encodeURIComponent(entry.name), {
+      method: 'POST', body: JSON.stringify({ input: args || {} }),
+    });
+    return asContent(res.ok ? res.data : res);
+  };
+}
+
+const webmcp = {
+  /** Every tool descriptor this page has registered (introspection + provideContext resends). */
+  tools: [],
+  /** The registration surface last used ('none' when no agent API is present). */
+  surface: 'none',
+
+  /** Low-level: register ready-made WebMCP tool descriptors ({name, description, inputSchema, execute}).
+   *  Re-registering a name REPLACES the earlier descriptor (idempotent across repeated expose calls). */
+  async register(tools) {
+    const names = tools.map(function (t) { return t.name; });
+    webmcp.tools = webmcp.tools.filter(function (t) { return names.indexOf(t.name) === -1; });
+    const surface = await registerWith(tools);
+    webmcp.tools = webmcp.tools.concat(tools);
+    webmcp.surface = surface;
+    return surface;
+  },
+
+  /**
+   * Expose an app's declared tools (apps.{appId}.tools manifest) to the in-browser agent.
+   * Descriptions of priced tools carry the price tag so the agent can tell the user the cost.
+   */
+  async exposeAppTools(ref) {
+    const listing = await fetchListing(ref.owner, ref.appId);
+    const tools = (listing.tools || []).map(function (entry) {
+      let desc = entry.description || entry.name;
+      if (entry.payment && entry.payment.required) {
+        const p = entry.payment;
+        const tags = [];
+        if (p.price) tags.push(p.price.morsels + ' morsels/call');
+        if (p.priceMoney) tags.push((p.priceMoney.amount / 1000000) + ' ' + p.priceMoney.currency + '/call');
+        desc = '[PAID: ' + tags.join(' or ') + '] ' + desc;
+      }
+      return {
+        name: entry.name,
+        description: desc,
+        inputSchema: entry.inputSchema || { type: 'object', properties: {} },
+        execute: buildExecute(ref.owner, ref.appId, entry),
+      };
+    });
+    await webmcp.register(tools);
+    return { surface: webmcp.surface, tools: tools.map(function (t) { return t.name; }) };
+  },
+
+  /** Node-level tools for the portal pages: public commerce/product discovery, no auth needed. */
+  async exposeNodeTools() {
+    const tools = [
+      {
+        name: 'aimeat-commerce-feed',
+        description: 'List everything for sale on this AIMEAT node: agent offers and priced app-tools (per-call functions of published apps), with prices in morsels or money micro-units.',
+        inputSchema: { type: 'object', properties: {} },
+        async execute() {
+          const r = await fetch(NODE_URL + '/v1/commerce/feed');
+          return asContent(await r.json());
+        },
+      },
+      {
+        name: 'aimeat-node-info',
+        description: 'Describe this AIMEAT node: identity, capabilities, discovery endpoints, and how agents connect.',
+        inputSchema: { type: 'object', properties: {} },
+        async execute() {
+          const r = await fetch(NODE_URL + '/.well-known/aimeat');
+          return asContent(await r.json());
+        },
+      },
+    ];
+    await webmcp.register(tools);
+    return { surface: webmcp.surface, tools: tools.map(function (t) { return t.name; }) };
+  },
+};
+
+// ── Expose globally + optional auto-activation from the script tag ──
+attach('webmcp', webmcp);
+
+try {
+  const el = /** @type {any} */ (typeof document !== 'undefined' && document.currentScript);
+  const src = el && el.src ? new URL(el.src, location.href) : null;
+  const expose = (src && src.searchParams.get('expose')) || (el && el.dataset && el.dataset.expose);
+  if (expose === 'node') {
+    // Defer past parse so a scanner's early modelContext shim is in place.
+    setTimeout(function () { webmcp.exposeNodeTools().catch(function () {}); }, 0);
+  }
+} catch { /* auto-activation is best-effort; explicit calls always work */ }

package/dist/static/sdk-libs/work/index.js

@@ -0,0 +1,191 @@
+/**
+ * @file work/index.js
+ * @description The aimeat-work library (SDK-libs migration Phase 2). Exposes AIMEAT.work — action
+ *   catalogue browsing (public) plus the work-exchange lifecycle (request/batch/inbox/status/accept/
+ *   progress/reject/deliver/rate + a waitFor poll helper). Authenticated calls go through the
+ *   AIMEAT.auth session; public catalogue/stats reads go direct to NODE_URL. Componentized ESM source
+ *   esbuild bundles to the IIFE served, unchanged, at /v1/libs/aimeat-work.js. Ported verbatim from
+ *   lib-work.ts; NODE_URL now comes from _core/config.
+ * @structure imports NODE_URL (config) + authFetch (session) + attach (namespace); publicFetch();
+ *   the `work` object; attach('work', …).
+ * @usage <script src="/v1/libs/aimeat-auth.js"></script><script src="/v1/libs/aimeat-work.js"></script>
+ *   const actions = await AIMEAT.work.catalogue();
+ * @version-history
+ *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-work.ts (SDK-libs migration Phase 2).
+ */
+import { NODE_URL } from '../_core/config.js';
+import { makeSession } from '../_core/session.js';
+const { authFetch } = makeSession('aimeat-work.js');
+import { attach } from '../_core/namespace.js';
+
+async function publicFetch(path) {
+  const r = await fetch(NODE_URL + path);
+  return r.json();
+}
+
+const work = {
+  // ── Catalogue (public, no auth) ──
+
+  // Browse action catalogue
+  async catalogue(opts) {
+    const params = new URLSearchParams();
+    if (opts?.search) params.set('search', opts.search);
+    if (opts?.category) params.set('category', opts.category);
+    if (opts?.page) params.set('page', String(opts.page));
+    if (opts?.per_page) params.set('per_page', String(opts.per_page));
+    const qs = params.toString();
+    const res = await publicFetch('/v1/catalogue' + (qs ? '?' + qs : ''));
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to browse catalogue');
+    return res.data;
+  },
+
+  // Get action details
+  async getAction(actionId) {
+    const res = await publicFetch('/v1/catalogue/' + encodeURIComponent(actionId));
+    if (!res.ok) {
+      if (res.error?.code === 'NOT_FOUND') return null;
+      throw new Error(res.error?.message || 'Failed to get action');
+    }
+    return res.data;
+  },
+
+  // Browse agent directory
+  async agents(opts) {
+    const params = new URLSearchParams();
+    if (opts?.page) params.set('page', String(opts.page));
+    if (opts?.per_page) params.set('per_page', String(opts.per_page));
+    const qs = params.toString();
+    const res = await publicFetch('/v1/catalogue/agents' + (qs ? '?' + qs : ''));
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to list agents');
+    return res.data;
+  },
+
+  // Get node stats
+  async stats() {
+    const res = await publicFetch('/v1/stats');
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to get stats');
+    return res.data;
+  },
+
+  // Catalogue change detection hash
+  async hash() {
+    const res = await publicFetch('/v1/catalogue/hash');
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to get hash');
+    return res.data;
+  },
+
+  // ── Work Requests (Tier 1, JWT auth) ──
+
+  // Submit a work request
+  async request(actionId, providerGaii, input, opts) {
+    const body = {
+      action_id: actionId,
+      provider_gaii: providerGaii,
+      input,
+      ...opts,
+    };
+    const res = await authFetch('/v1/work/request', {
+      method: 'POST', body: JSON.stringify(body),
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to submit work request');
+    return res.data;
+  },
+
+  // Submit batch work requests
+  async batch(requests) {
+    const res = await authFetch('/v1/work/batch', {
+      method: 'POST', body: JSON.stringify({ requests }),
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to submit batch');
+    return res.data;
+  },
+
+  // ── Provider Inbox ──
+
+  // Get pending work items (provider perspective)
+  async inbox() {
+    const res = await authFetch('/v1/work/inbox');
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to get inbox');
+    return res.data;
+  },
+
+  // ── Work Status & Actions ──
+
+  // Get work status by tracking code
+  async status(trackingCode) {
+    const res = await authFetch('/v1/work/' + encodeURIComponent(trackingCode));
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to get work status');
+    return res.data;
+  },
+
+  // Accept work (provider)
+  async accept(trackingCode) {
+    const res = await authFetch('/v1/work/' + encodeURIComponent(trackingCode) + '/accept', {
+      method: 'POST',
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to accept work');
+    return res.data;
+  },
+
+  // Mark work as in_progress (provider)
+  async progress(trackingCode) {
+    const res = await authFetch('/v1/work/' + encodeURIComponent(trackingCode) + '/progress', {
+      method: 'POST',
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to update progress');
+    return res.data;
+  },
+
+  // Reject work (provider)
+  async reject(trackingCode, reason) {
+    const res = await authFetch('/v1/work/' + encodeURIComponent(trackingCode) + '/reject', {
+      method: 'POST', body: JSON.stringify({ reason }),
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to reject work');
+    return res.data;
+  },
+
+  // Deliver work output (provider)
+  async deliver(trackingCode, output, metadata) {
+    const body = /** @type {Record<string, any>} */ ({ output });
+    if (metadata) body.metadata = metadata;
+    const res = await authFetch('/v1/work/' + encodeURIComponent(trackingCode) + '/deliver', {
+      method: 'POST', body: JSON.stringify(body),
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to deliver work');
+    return res.data;
+  },
+
+  // Rate a delivery (requester)
+  async rate(trackingCode, rating, comment) {
+    const body = /** @type {Record<string, any>} */ ({ rating });
+    if (comment) body.comment = comment;
+    const res = await authFetch('/v1/work/' + encodeURIComponent(trackingCode) + '/rate', {
+      method: 'POST', body: JSON.stringify(body),
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to rate work');
+    return res.data;
+  },
+
+  // ── Convenience: Poll for completion ──
+  async waitFor(trackingCode, opts) {
+    const interval = opts?.interval || 2000;
+    const timeout = opts?.timeout || 60000;
+    const start = Date.now();
+
+    while (Date.now() - start < timeout) {
+      const data = await work.status(trackingCode);
+      if (data.status === 'delivered' || data.status === 'rated' || data.status === 'completed') {
+        return data;
+      }
+      if (data.status === 'rejected' || data.status === 'expired' || data.status === 'failed') {
+        throw new Error('Work ' + data.status + ': ' + (data.output || trackingCode));
+      }
+      await new Promise(r => setTimeout(r, interval));
+    }
+    throw new Error('Work timed out after ' + timeout + 'ms');
+  },
+};
+
+// ── Expose globally ──
+attach('work', work);

package/dist/static/sdk-libs/workflows/index.js

@@ -0,0 +1,113 @@
+/**
+ * @file workflows/index.js
+ * @description The aimeat-workflows library (SDK-libs migration Phase 1). Exposes AIMEAT.workflows —
+ *   the Agent Workflows client: list/get/save/remove definitions, run (signals-only | full,
+ *   sandbox|live), runs + health + blueprint reads, run cancel, and the human-in-the-loop surface
+ *   (pendingInputs + answer + watchRun over the aimeat-live 'workflows' domain, polling fallback).
+ *   Calls /v1/workflows via the AIMEAT.auth session (needs workflow:read / workflow:write grant
+ *   scopes). Componentized ESM source esbuild bundles to the IIFE served, unchanged, at
+ *   /v1/libs/aimeat-workflows.js. Ported verbatim from lib-workflows.ts.
+ * @structure imports authFetch (session) + attach (namespace); call() envelope wrapper (typed
+ *   err.code/details); the `workflows` object incl. watchRun; attach('workflows', …).
+ * @usage <script src="/v1/libs/aimeat-auth.js"></script><script src="/v1/libs/aimeat-workflows.js"></script>
+ *   const { runId } = await AIMEAT.workflows.run('my-flow', { mode: 'full', sandbox: true });
+ * @version-history
+ *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-workflows.ts (SDK-libs migration Phase 1).
+ */
+import { makeSession } from '../_core/session.js';
+const { authFetch } = makeSession('aimeat-workflows.js');
+import { attach } from '../_core/namespace.js';
+
+async function call(path, opts) {
+  const res = await authFetch(path, opts);
+  if (!res.ok) {
+    const err = /** @type {Error & { code?: string, details?: unknown }} */ (new Error((res.error && res.error.message) || 'Workflow request failed'));
+    err.code = res.error && res.error.code;
+    err.details = res.error && res.error.details;
+    throw err;
+  }
+  return res.data;
+}
+
+const workflows = {
+  // ── definitions ──
+  // List the owner's workflow definitions. { includeHealth: true } inlines each workflow's
+  // run-health trend (avoids a per-workflow health() fan-out on list views).
+  async list(opts) {
+    const qs = opts && opts.includeHealth ? '?include=health' : '';
+    return call('/v1/workflows' + qs);
+  },
+  async get(id) { return call('/v1/workflows/' + encodeURIComponent(id)); },
+  // Create or update. def = { title, description, trigger, vars, steps, on_step_fail:'inspect', ... }.
+  // Rejected (error.details.errors[]) unless the graph is a DAG and every agent step's offer is
+  // workflow-compatible. Steps may also be actions: export-out / trigger-geai / human-input.
+  async save(id, def) { return call('/v1/workflows/' + encodeURIComponent(id), { method: 'PUT', body: JSON.stringify(def) }); },
+  async remove(id, opts) {
+    const qs = opts && opts.withRuns ? '?withRuns=true' : '';
+    return call('/v1/workflows/' + encodeURIComponent(id) + qs, { method: 'DELETE' });
+  },
+  // The derived structural graph (nodes + edges + memory keys each step reads/writes) — feed a canvas.
+  async blueprint(id) { return call('/v1/workflows/' + encodeURIComponent(id) + '/blueprint'); },
+  async health(id) { return call('/v1/workflows/' + encodeURIComponent(id) + '/health'); },
+
+  // ── runs ──
+  // mode: 'signals' (evaluate signals only, no dispatch — instant health check) | 'full' (execute).
+  // sandbox: true namespaces every key under wf-test.<runId>. so a test run never clobbers prod.
+  async run(id, opts) {
+    const body = {
+      mode: opts && opts.mode === 'full' ? 'full' : 'signals-only',
+      target: opts && opts.sandbox ? 'sandbox' : 'live',
+      vars: (opts && opts.vars) || undefined,
+    };
+    return call('/v1/workflows/' + encodeURIComponent(id) + '/run', { method: 'POST', body: JSON.stringify(body) });
+  },
+  async runs(id) { return call('/v1/workflows/' + encodeURIComponent(id) + '/runs'); },
+  async getRun(id, runId) { return call('/v1/workflows/' + encodeURIComponent(id) + '/runs/' + encodeURIComponent(runId)); },
+  async cancel(id, runId) { return call('/v1/workflows/' + encodeURIComponent(id) + '/runs/' + encodeURIComponent(runId) + '/cancel', { method: 'POST' }); },
+
+  // ── human-in-the-loop ──
+  // Every step across the owner's active runs currently waiting for a human answer:
+  // [{ workflowId, runId, stepId, workflowTitle, question:{prompt,options,...}, askedAt, deadline }].
+  async pendingInputs() { return call('/v1/workflows/pending-inputs'); },
+  // Answer a waiting-human step. answer = { picks: ['option-id'], other?: 'free text' }. 409 when the
+  // step is not parked (already answered / timed out); the run advances on success.
+  async answer(id, runId, stepId, answer) {
+    return call('/v1/workflows/' + encodeURIComponent(id) + '/runs/' + encodeURIComponent(runId)
+      + '/steps/' + encodeURIComponent(stepId) + '/answer', { method: 'POST', body: JSON.stringify(answer) });
+  },
+
+  // ── live watching ──
+  // Re-fetch a run whenever the 'workflows' SSE domain ticks (via aimeat-live when loaded; falls back
+  // to polling every pollMs, default 5000). cb(run) fires on every fetch; returns a stop() function.
+  // Stops itself automatically when the run reaches a terminal state.
+  watchRun(id, runId, cb, opts) {
+    let stopped = false;
+    let unsub = null;
+    let timer = null;
+    const TERMINAL = { done: 1, partial: 1, red: 1, cancelled: 1 };
+    const pull = async () => {
+      if (stopped) return;
+      try {
+        const run = await workflows.getRun(id, runId);
+        cb(run);
+        if (run && TERMINAL[run.status]) stop();
+      } catch { /* transient — keep watching */ }
+    };
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      if (unsub) try { unsub(); } catch { /* noop */ }
+      if (timer) clearInterval(timer);
+    };
+    if (window.AIMEAT.live && typeof window.AIMEAT.live.subscribe === 'function') {
+      unsub = window.AIMEAT.live.subscribe(['workflows'], pull);
+    } else {
+      timer = setInterval(pull, (opts && opts.pollMs) || 5000);
+    }
+    pull();
+    return stop;
+  },
+};
+
+// ── Expose globally ──
+attach('workflows', workflows);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aimeat",
-  "version": "1.40.1",
+  "version": "2.1.0",
   "description": "AIME AT - AI Memory Exchange and Action Transfer - reference implementation",
   "type": "module",
   "main": "dist/src/index.js",
@@ -12,7 +12,6 @@
   },
   "files": [
     "dist/",
-    "prisma/",
     "docs/AIMEAT_Help_Prompt.md",
     "docs/csm-examples/"
   ],
@@ -55,10 +54,12 @@
     "ini": "^7.0.0",
     "javascript-obfuscator": "^5.4.3",
     "jose": "^6.2.3",
+    "kysely": "^0.29.3",
     "minidenticons": "^4.2.1",
     "nodemailer": "^8.0.11",
     "openid-client": "^6.8.4",
     "otpauth": "^9.5.1",
+    "pg": "^8.22.0",
     "playwright-core": "1.60.0",
     "prom-client": "^15.1.3",
     "qrcode": "^1.5.4",
@@ -83,6 +84,7 @@
     "@types/ini": "^4.1.1",
     "@types/node": "^25.9.3",
     "@types/nodemailer": "^8.0.1",
+    "@types/pg": "^8.20.0",
     "@types/qrcode": "^1.5.6",
     "@types/web-push": "^3.6.4",
     "@types/ws": "^8.18.1",
@@ -91,22 +93,26 @@
     "esbuild": "0.28.1",
     "eslint": "^10.5.0",
     "eslint-plugin-react-hooks": "^7.1.1",
+    "kysely-codegen": "^0.20.0",
     "openapi-typescript": "^7.8.0",
-    "prisma": "^6.9.0",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.61.0",
+    "viem": "^2.55.2",
     "vitest": "^4.1.8"
   },
-  "optionalDependencies": {
-    "@prisma/client": "^6.19.2"
-  },
   "scripts": {
-    "dev": "tsx scripts/kill-port.ts && tsx scripts/build-app-catalog.ts && node --env-file=.env --import tsx src/index.ts start",
+    "dev": "tsx scripts/kill-port.ts && tsx scripts/build-app-catalog.ts && tsx scripts/build-sdk-libs.ts && node --env-file=.env --import tsx src/index.ts start",
     "dev:watch": "tsx watch src/index.ts",
-    "build": "prisma generate && prisma generate --schema prisma/schema.postgres.prisma && tsc && node --input-type=module -e \"import fs from 'fs';fs.cpSync('locales','dist/locales',{recursive:true});fs.cpSync('public','dist/public',{recursive:true});fs.cpSync('src/static','dist/static',{recursive:true});fs.cpSync('.env.example','dist/.env.example');fs.cpSync('src/generated/prisma-postgres','dist/src/generated/prisma-postgres',{recursive:true});\"",
+    "build": "tsc && node --input-type=module -e \"import fs from 'fs';fs.cpSync('locales','dist/locales',{recursive:true});fs.cpSync('public','dist/public',{recursive:true});fs.cpSync('src/static','dist/static',{recursive:true});fs.cpSync('.env.example','dist/.env.example');fs.cpSync('src/storage/providers/postgres-kysely/migrations','dist/src/storage/providers/postgres-kysely/migrations',{recursive:true});\"",
     "build:app-catalog": "tsx scripts/build-app-catalog.ts",
     "check:app-catalog": "tsx scripts/build-app-catalog.ts --check",
+    "build:sdk": "tsx scripts/build-sdk-libs.ts",
+    "check:sdk": "tsx scripts/build-sdk-libs.ts --check",
+    "check:mcp-tools": "tsx scripts/audit-mcp-tools.ts --check",
+    "check:packs-doc": "vitest run test/unit/library-packs-doc-truth.test.ts",
+    "aeb:prove": "tsx scripts/aeb-prove.ts",
+    "aeb:ledger": "tsx scripts/aeb-ledger.ts",
     "start": "node --env-file=.env dist/src/index.js start",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
@@ -158,28 +164,22 @@
     "test:e2e:docker:storage-visibility": "bash test/docker/e2e-runner.sh test/e2e-storage-visibility.ts",
     "test:e2e": "node --env-file=.env.test.memory --import tsx test/run-e2e-ci.ts",
     "test:e2e:memory": "node --env-file=.env.test.memory --import tsx test/run-e2e-ci.ts",
-    "test:e2e:sqlite": "node --env-file=.env.test.sqlite --import tsx test/run-e2e-ci.ts",
-    "test:e2e:mongodb": "node --env-file=.env.test.mongodb --import tsx test/run-e2e-ci.ts",
-    "test:e2e:postgresql": "node --env-file=.env.test.postgres --import tsx test/run-e2e-ci.ts",
-    "test:playwright": "node --env-file=.env.test.memory --import tsx test/run-playwright-ci.ts",
-    "test:playwright:memory": "node --env-file=.env.test.memory --import tsx test/run-playwright-ci.ts",
+    "test:e2e:sqlite": "tsx scripts/kill-test-servers.ts && node --env-file=.env.test.sqlite --import tsx test/run-e2e-ci.ts",
+    "test:e2e:postgres-kysely": "tsx scripts/kill-test-servers.ts && node --env-file=.env.test.postgres-kysely --import tsx test/run-e2e-ci.ts",
+    "test:playwright": "node --env-file=.env.test.sqlite --import tsx test/run-playwright-ci.ts",
     "test:playwright:sqlite": "node --env-file=.env.test.sqlite --import tsx test/run-playwright-ci.ts",
-    "test:playwright:mongodb": "node --env-file=.env.test.mongodb --import tsx test/run-playwright-ci.ts",
-    "test:e2e:all-backends": "node --env-file=.env.test.sqlite --import tsx test/run-e2e-ci.ts --all && node --env-file=.env.test.mongodb --import tsx test/run-e2e-ci.ts --all && node --env-file=.env.test.postgres --import tsx test/run-e2e-ci.ts --all",
+    "test:playwright:postgres-kysely": "node --env-file=.env.test.postgres-kysely --import tsx test/run-playwright-ci.ts",
+    "test:e2e:all-backends": "node --env-file=.env.test.sqlite --import tsx test/run-e2e-ci.ts --all && node --env-file=.env.test.postgres-kysely --import tsx test/run-e2e-ci.ts --all",
     "test:e2e:ci": "node --import tsx test/run-e2e-ci.ts --all",
     "test:e2e:ci:filter": "node --import tsx test/run-e2e-ci.ts",
     "lint": "eslint src/ public/ --max-warnings 0",
     "typecheck": "tsc --noEmit",
     "typecheck:frontend": "tsc --noEmit -p tsconfig.frontend.json",
+    "typecheck:sdk": "tsc --noEmit -p tsconfig.sdk.json",
     "check:importmap": "tsx scripts/check-importmap.ts",
     "check:no-max-tokens": "tsx scripts/check-no-max-tokens.ts",
     "screenshot:worker": "tsx scripts/screenshot-worker.ts",
     "generate:types": "openapi-typescript ../openapi.yaml -o src/generated/api-types.ts",
-    "db:generate": "prisma generate",
-    "db:generate:postgres": "prisma generate --schema prisma/schema.postgres.prisma",
-    "db:push": "prisma db push",
-    "db:push:postgres": "prisma db push --schema prisma/schema.postgres.prisma",
-    "db:init": "node --env-file=.env --import tsx scripts/db-init.ts",
     "db:reset": "node --env-file=.env --import tsx scripts/db-reset.ts",
     "telemetry:stats": "node --env-file=.env --import tsx scripts/telemetry-prune.ts",
     "telemetry:prune": "node --env-file=.env --import tsx scripts/telemetry-prune.ts",
@@ -193,6 +193,8 @@
     "audit:fix": "pnpm audit --fix",
     "audit:mcp-tools": "tsx scripts/audit-mcp-tools.ts",
     "audit:mcp-schemas": "tsx scripts/audit-mcp-schemas.ts",
-    "eval:mcp-surface": "tsx test/eval-mcp/surface-weight.ts"
+    "eval:mcp-surface": "tsx test/eval-mcp/surface-weight.ts",
+    "perf:bench": "node --import tsx tools/perf-bench/bench.ts",
+    "perf:bench:backends": "node --import tsx tools/perf-bench/bench-backends.ts"
   }
 }