trellis 3.2.2 → 3.2.4

package/dist/{chunk-SPSPV5BC.js → chunk-SZ3VAB5P.js}

@@ -349,6 +349,157 @@ function findEntityId(binding) {
   return void 0;
 }
 
+// src/core/kernel/schema-middleware.ts
+function createSchemaMiddleware(config) {
+  const strict = config.strict ?? true;
+  return {
+    name: "schema-validation",
+    async handleOp(op, ctx, next) {
+      if (!op.facts || op.facts.length === 0) {
+        return next(op, ctx);
+      }
+      const ontologies = config.getOntologies();
+      const errors = [];
+      const entities = new Set(
+        op.facts.filter((fact) => fact.a === "type").map((fact) => fact.e)
+      );
+      for (const entityId of entities) {
+        const typeFact = op.facts.find((fact) => fact.e === entityId && fact.a === "type");
+        if (!typeFact) continue;
+        const entityType = String(typeFact.v);
+        const schema = resolveSchemaForEntity(entityType, entityId, op.facts, ontologies);
+        if (!schema) continue;
+        for (const fact of op.facts) {
+          if (fact.e !== entityId) continue;
+          const fieldSpec = schema.fields.find((field) => field.name === fact.a);
+          if (!fieldSpec) continue;
+          const validationError = validateValue(fact.a, fact.v, fieldSpec);
+          if (validationError) errors.push(validationError);
+        }
+        for (const fieldSpec of schema.fields) {
+          if (!fieldSpec.required) continue;
+          const hasValue = op.facts.some(
+            (fact) => fact.e === entityId && fact.a === fieldSpec.name && fact.v !== null && fact.v !== void 0 && fact.v !== ""
+          );
+          if (!hasValue) {
+            errors.push(`Missing required field: ${fieldSpec.name} on entity ${entityId}`);
+          }
+        }
+      }
+      if (errors.length > 0 && strict) {
+        const errorMsg = [...new Set(errors)].join("; ");
+        throw new Error(`Schema validation failed: ${errorMsg}`);
+      }
+      return next(op, ctx);
+    }
+  };
+}
+function collectionSlugFromCollectionId(collectionId) {
+  const prefix = "collectionMeta:";
+  if (!collectionId.startsWith(prefix)) return null;
+  const slug = collectionId.slice(prefix.length).trim();
+  return slug || null;
+}
+function findPerCollectionRecordSchema(slug, ontologies) {
+  const suffix = `/collections/${slug}/Record`;
+  for (const schema of ontologies.values()) {
+    if (schema["@id"].endsWith(suffix)) return schema;
+  }
+  return void 0;
+}
+function resolveSchemaForEntity(entityType, entityId, facts, ontologies) {
+  const shortType = entityType.includes(":") ? entityType.split(":").pop() : entityType;
+  if (shortType === "CollectionRecord") {
+    const collectionIdFact = facts.find(
+      (fact) => fact.e === entityId && fact.a === "collectionId"
+    );
+    const slug = collectionIdFact ? collectionSlugFromCollectionId(String(collectionIdFact.v)) : null;
+    if (slug) {
+      const perCollection = findPerCollectionRecordSchema(slug, ontologies);
+      if (perCollection?.fields?.length) return perCollection;
+    }
+  }
+  return ontologies.get(entityType) ?? ontologies.get(shortType) ?? ontologies.get(shortType.toLowerCase()) ?? ontologies.get(entityType.toLowerCase());
+}
+function validateValue(fieldName, value, spec) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  const actualType = typeof value;
+  switch (spec.valueType) {
+    case "title":
+    case "rich_text":
+    case "select":
+    case "multi_select":
+    case "status":
+    case "phone_number":
+    case "url":
+    case "email": {
+      if (actualType !== "string") {
+        return `Field ${fieldName}: expected string, got ${actualType}`;
+      }
+      const text = value;
+      if (spec.minLength !== void 0 && text.length < spec.minLength) {
+        return `Field ${fieldName}: must be at least ${spec.minLength} characters`;
+      }
+      if (spec.maxLength !== void 0 && text.length > spec.maxLength) {
+        return `Field ${fieldName}: must be at most ${spec.maxLength} characters`;
+      }
+      if (spec.pattern) {
+        try {
+          if (!new RegExp(spec.pattern).test(text)) {
+            return `Field ${fieldName}: invalid format`;
+          }
+        } catch {
+        }
+      }
+      if (spec.selectOptions && spec.selectOptions.length > 0) {
+        if (!spec.selectOptions.includes(value)) {
+          return `Field ${fieldName}: value "${value}" not in allowed options`;
+        }
+      }
+      break;
+    }
+    case "number":
+      if (actualType !== "number") {
+        return `Field ${fieldName}: expected number, got ${actualType}`;
+      }
+      if (spec.min !== void 0 && value < spec.min) {
+        return `Field ${fieldName}: value ${value} below minimum ${spec.min}`;
+      }
+      if (spec.max !== void 0 && value > spec.max) {
+        return `Field ${fieldName}: value ${value} above maximum ${spec.max}`;
+      }
+      break;
+    case "checkbox":
+      if (actualType !== "boolean") {
+        return `Field ${fieldName}: expected boolean, got ${actualType}`;
+      }
+      break;
+    case "date":
+      if (actualType === "string") {
+        const date = new Date(value);
+        if (isNaN(date.getTime())) {
+          return `Field ${fieldName}: invalid date format`;
+        }
+      } else if (actualType !== "object") {
+        return `Field ${fieldName}: expected date string or object, got ${actualType}`;
+      }
+      break;
+    case "files":
+    case "people":
+    case "relation":
+    case "rollup":
+    case "formula":
+    case "ai_generated":
+    case "json":
+      break;
+    default:
+      break;
+  }
+  return null;
+}
+
 // src/core/kernel/boot-middleware.ts
 function buildOntologyIndex(schemas) {
   const map = /* @__PURE__ */ new Map();
@@ -368,10 +519,16 @@ function buildOntologyIndex(schemas) {
 }
 function attachStandardMiddleware(kernel) {
   kernel.removeMiddleware("logic-computation");
-  const ontologies = buildOntologyIndex(kernel.listOntologies());
+  kernel.removeMiddleware("schema-validation");
+  const getOntologies = () => buildOntologyIndex(kernel.listOntologies());
+  kernel.addMiddleware(
+    createSchemaMiddleware({
+      getOntologies
+    })
+  );
   kernel.addMiddleware(
     createLogicMiddleware({
-      ontologies,
+      ontologies: getOntologies(),
       getStore: () => kernel.getStore(),
       getEntityType: (entityId) => kernel.getEntity(entityId)?.type
     })

package/dist/chunk-V2ASD6RQ.js

@@ -0,0 +1,147 @@
+import {
+  loadVmConfig
+} from "./chunk-UZRUP7QW.js";
+import {
+  readConfig
+} from "./chunk-JA7AIHRK.js";
+
+// src/mcp/gateway-config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+var GATEWAY_CONFIG_FILE = ".trellis-mcp-gateway.json";
+function gatewayConfigPath(dir = ".") {
+  return resolve(join(dir, GATEWAY_CONFIG_FILE));
+}
+function readGatewayConfig(dir = ".") {
+  const path = gatewayConfigPath(dir);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw new Error(`Failed to parse ${path}: invalid JSON`);
+  }
+}
+function writeGatewayConfig(config, dir = ".") {
+  writeFileSync(
+    gatewayConfigPath(dir),
+    JSON.stringify(config, null, 2) + "\n",
+    "utf8"
+  );
+}
+
+// src/mcp/room-registry.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function normalizeBaseUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function roomMcpPathForUrl(baseUrl) {
+  const env = process.env.TRELLIS_MCP_PATH?.trim();
+  if (env) return env.startsWith("/") ? env : `/${env}`;
+  try {
+    const host = new URL(baseUrl).hostname;
+    if (/\.sprites\.app$/i.test(host)) return "/trellis/mcp";
+  } catch {
+  }
+  return "/mcp";
+}
+function toMcpUrl(base) {
+  const trimmed = normalizeBaseUrl(base);
+  if (trimmed.endsWith("/mcp") || trimmed.endsWith("/trellis/mcp")) {
+    return trimmed;
+  }
+  return `${trimmed}${roomMcpPathForUrl(trimmed)}`;
+}
+function parseRegistryJson(raw, source) {
+  try {
+    const data = JSON.parse(raw);
+    const rooms = Array.isArray(data) ? data : data.rooms ?? [];
+    return rooms.filter((r) => r.name && r.url).map((r) => ({
+      name: r.name,
+      url: normalizeBaseUrl(r.url),
+      mcpUrl: r.mcpUrl ? normalizeBaseUrl(r.mcpUrl) : toMcpUrl(r.url),
+      apiKey: r.apiKey,
+      source,
+      deployedAt: r.deployedAt,
+      active: r.active
+    }));
+  } catch {
+    return [];
+  }
+}
+function listRegisteredRooms(opts = {}) {
+  const configDir = opts.configDir ?? ".";
+  const byUrl = /* @__PURE__ */ new Map();
+  const envRooms = process.env.TRELLIS_MCP_GATEWAY_ROOMS?.trim();
+  if (envRooms) {
+    for (const room of parseRegistryJson(envRooms, "env")) {
+      byUrl.set(room.url, room);
+    }
+  }
+  const registryPath = process.env.TRELLIS_ROOM_REGISTRY?.trim() ?? resolve2(configDir, ".trellis-rooms.json");
+  if (existsSync2(registryPath)) {
+    try {
+      const raw = readFileSync2(registryPath, "utf8");
+      for (const room of parseRegistryJson(raw, "registry")) {
+        byUrl.set(room.url, room);
+      }
+    } catch {
+    }
+  }
+  const vm = loadVmConfig();
+  for (const [name, sprite] of Object.entries(vm.sprites)) {
+    if (!sprite.hasTrellis && !sprite.apiKey) continue;
+    const url = normalizeBaseUrl(sprite.url);
+    byUrl.set(url, {
+      name,
+      url,
+      mcpUrl: toMcpUrl(url),
+      apiKey: sprite.apiKey,
+      source: "vm",
+      active: vm.activeSprite === name
+    });
+  }
+  const dbConfig = readConfig(configDir);
+  if (dbConfig?.mode === "remote" && dbConfig.url) {
+    const url = normalizeBaseUrl(dbConfig.url);
+    const name = dbConfig.spriteName ?? url.replace(/^https?:\/\//, "").split(".")[0];
+    if (!byUrl.has(url)) {
+      byUrl.set(url, {
+        name,
+        url,
+        mcpUrl: toMcpUrl(url),
+        apiKey: dbConfig.apiKey,
+        source: "project",
+        deployedAt: dbConfig.deployedAt,
+        active: true
+      });
+    }
+  }
+  return [...byUrl.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function getRegisteredRoom(nameOrUrl, opts) {
+  const needle = nameOrUrl.trim().toLowerCase();
+  const rooms = listRegisteredRooms(opts);
+  return rooms.find(
+    (r) => r.name.toLowerCase() === needle || r.url.toLowerCase() === needle || r.mcpUrl.toLowerCase() === needle || normalizeBaseUrl(needle).endsWith(r.name.toLowerCase())
+  ) ?? null;
+}
+function gatewayPublicUrl(opts) {
+  const fromConfig = readGatewayConfig(opts?.configDir ?? ".")?.publicUrl?.trim();
+  if (fromConfig) return fromConfig.replace(/\/$/, "");
+  if (opts?.gatewayPublicUrl?.trim()) {
+    return opts.gatewayPublicUrl.trim().replace(/\/$/, "");
+  }
+  const env = process.env.TRELLIS_MCP_GATEWAY_PUBLIC_URL?.trim();
+  if (env) return env.replace(/\/$/, "");
+  return "https://mcp.trellis.computer";
+}
+
+export {
+  gatewayConfigPath,
+  writeGatewayConfig,
+  roomMcpPathForUrl,
+  listRegisteredRooms,
+  getRegisteredRoom,
+  gatewayPublicUrl
+};

package/dist/{chunk-KQ4A2D2P.js → chunk-V4YCJDYL.js}

@@ -4,7 +4,7 @@ import {
 import {
   EAVStore,
   init_eav_store
-} from "./chunk-4XIVMVHC.js";
+} from "./chunk-G3XIHPSQ.js";
 
 // src/core/kernel/trellis-kernel.ts
 init_eav_store();
@@ -541,11 +541,11 @@ var TrellisKernel = class {
    * Create a new entity with the given type and attributes.
    * Returns the entity ID.
    */
-  async createEntity(entityId, type, attributes = {}, links) {
-    const facts = [
-      { e: entityId, a: "type", v: type },
-      { e: entityId, a: "createdAt", v: (/* @__PURE__ */ new Date()).toISOString() }
-    ];
+  async createEntity(entityId, type, attributes = {}, links, ctx) {
+    const facts = [{ e: entityId, a: "type", v: type }];
+    if (attributes.createdAt === void 0) {
+      facts.push({ e: entityId, a: "createdAt", v: (/* @__PURE__ */ new Date()).toISOString() });
+    }
     for (const [attr, value] of Object.entries(attributes)) {
       facts.push({ e: entityId, a: attr, v: value });
     }
@@ -554,10 +554,14 @@ var TrellisKernel = class {
       a: l.attribute,
       e2: l.targetEntityId
     }));
-    return this.mutate("addFacts", {
-      facts,
-      links: linkRecords.length > 0 ? linkRecords : void 0
-    });
+    return this.mutate(
+      "addFacts",
+      {
+        facts,
+        links: linkRecords.length > 0 ? linkRecords : void 0
+      },
+      ctx
+    );
   }
   /**
    * Get an entity by ID, returning all its facts and links.
@@ -576,7 +580,7 @@ var TrellisKernel = class {
   /**
    * Update an entity's attributes. Deletes old values and adds new ones.
    */
-  async updateEntity(entityId, updates) {
+  async updateEntity(entityId, updates, ctx) {
     const existingFacts = this.store.getFactsByEntity(entityId);
     const deleteFacts = [];
     const addFacts = [];
@@ -588,21 +592,29 @@ var TrellisKernel = class {
     const updatedAtFacts = existingFacts.filter((f2) => f2.a === "updatedAt");
     deleteFacts.push(...updatedAtFacts);
     addFacts.push({ e: entityId, a: "updatedAt", v: (/* @__PURE__ */ new Date()).toISOString() });
-    return this.mutate("addFacts", {
-      facts: addFacts,
-      deleteFacts
-    });
+    return this.mutate(
+      "addFacts",
+      {
+        facts: addFacts,
+        deleteFacts
+      },
+      ctx
+    );
   }
   /**
    * Delete an entity and all its facts and links.
    */
-  async deleteEntity(entityId) {
+  async deleteEntity(entityId, ctx) {
     const facts = this.store.getFactsByEntity(entityId);
     const links = this.store.getLinksByEntity(entityId);
-    return this.mutate("deleteFacts", {
-      deleteFacts: facts,
-      deleteLinks: links
-    });
+    return this.mutate(
+      "deleteFacts",
+      {
+        deleteFacts: facts,
+        deleteLinks: links
+      },
+      ctx
+    );
   }
   /**
    * List entities by type, with optional attribute filters.
@@ -632,18 +644,26 @@ var TrellisKernel = class {
   /**
    * Add a link between two entities.
    */
-  async addLink(sourceId, attribute, targetId) {
-    return this.mutate("addLinks", {
-      links: [{ e1: sourceId, a: attribute, e2: targetId }]
-    });
+  async addLink(sourceId, attribute, targetId, ctx) {
+    return this.mutate(
+      "addLinks",
+      {
+        links: [{ e1: sourceId, a: attribute, e2: targetId }]
+      },
+      ctx
+    );
   }
   /**
    * Remove a link between two entities.
    */
-  async removeLink(sourceId, attribute, targetId) {
-    return this.mutate("deleteLinks", {
-      deleteLinks: [{ e1: sourceId, a: attribute, e2: targetId }]
-    });
+  async removeLink(sourceId, attribute, targetId, ctx) {
+    return this.mutate(
+      "deleteLinks",
+      {
+        deleteLinks: [{ e1: sourceId, a: attribute, e2: targetId }]
+      },
+      ctx
+    );
   }
   /**
    * Add a fact to an entity.
@@ -837,32 +857,32 @@ var TrellisKernel = class {
   /**
    * Create a node (alias for createEntity with schema validation).
    */
-  async createNode(id, data, type, _ctx) {
-    return this.createEntity(id, type, data);
+  async createNode(id, data, type, ctx) {
+    return this.createEntity(id, type, data, void 0, ctx);
   }
   /**
    * Update a node (alias for updateEntity with schema validation).
    */
-  async updateNode(id, data, type, _ctx) {
-    return this.updateEntity(id, data);
+  async updateNode(id, data, type, ctx) {
+    return this.updateEntity(id, data, ctx);
   }
   /**
    * Delete a node (alias for deleteEntity).
    */
-  async deleteNode(id, _ctx) {
-    return this.deleteEntity(id);
+  async deleteNode(id, ctx) {
+    return this.deleteEntity(id, ctx);
   }
   /**
    * Link two nodes (alias for addLink).
    */
-  async link(e1, a, e2, _ctx) {
-    return this.addLink(e1, a, e2);
+  async link(e1, a, e2, ctx) {
+    return this.addLink(e1, a, e2, ctx);
   }
   /**
    * Unlink two nodes (alias for removeLink).
    */
-  async unlink(e1, a, e2, _ctx) {
-    return this.removeLink(e1, a, e2);
+  async unlink(e1, a, e2, ctx) {
+    return this.removeLink(e1, a, e2, ctx);
   }
   // -------------------------------------------------------------------------
   // Middleware

package/dist/{chunk-LNUIGRDZ.js → chunk-VWKLKLYB.js}

@@ -1,6 +1,6 @@
 import {
   __require
-} from "./chunk-KFQGP6VL.js";
+} from "./chunk-2ESYSVXG.js";
 
 // src/core/persist/sqljs-backend.ts
 var SCHEMA_SQL = `