trellis 3.1.35 → 3.2.0

package/dist/chunk-5IQZFITY.js

@@ -0,0 +1,357 @@
+import {
+  TenantPool
+} from "./chunk-HGRA37LO.js";
+import {
+  readConfig
+} from "./chunk-JA7AIHRK.js";
+
+// src/client/sdk.ts
+function isRemote(opts) {
+  return "url" in opts;
+}
+var TrellisDb = class _TrellisDb {
+  opts;
+  _pool = null;
+  _ws = null;
+  _subCallbacks = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Create a TrellisDb instance from `.trellis-db.json` in the given directory.
+   */
+  static fromConfig(dir = ".") {
+    const config = readConfig(dir);
+    if (!config)
+      throw new Error(
+        "No .trellis-db.json found. Run `trellis db init` first."
+      );
+    if (config.mode === "remote" && config.url) {
+      return new _TrellisDb({ url: config.url, apiKey: config.apiKey });
+    }
+    if (config.dbPath) {
+      return new _TrellisDb({ path: config.dbPath });
+    }
+    throw new Error("Invalid .trellis-db.json: missing url or dbPath.");
+  }
+  // -------------------------------------------------------------------------
+  // CRUD
+  // -------------------------------------------------------------------------
+  /**
+   * Create a new entity.
+   * Returns the generated entity ID.
+   */
+  async create(type, attributes = {}, links) {
+    if (isRemote(this.opts)) {
+      const res = await this._fetch("POST", "/entities", {
+        type,
+        attributes,
+        links
+      });
+      return res.id;
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entityId = `${type.toLowerCase()}:${crypto.randomUUID()}`;
+    await kernel.createEntity(entityId, type, attributes, links);
+    return entityId;
+  }
+  /**
+   * Read an entity by ID.
+   * Returns null if not found.
+   */
+  async read(id) {
+    if (isRemote(this.opts)) {
+      try {
+        return await this._fetch(
+          "GET",
+          `/entities/${encodeURIComponent(id)}`
+        );
+      } catch (err) {
+        if (err?.status === 404) return null;
+        throw err;
+      }
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entity = kernel.getEntity(id);
+    if (!entity) return null;
+    return entityToPlain(entity);
+  }
+  /**
+   * Update an entity's attributes (partial update).
+   */
+  async update(id, attributes) {
+    if (isRemote(this.opts)) {
+      await this._fetch(
+        "PUT",
+        `/entities/${encodeURIComponent(id)}`,
+        attributes
+      );
+      return;
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    await kernel.updateEntity(id, attributes);
+  }
+  /**
+   * Delete an entity by ID.
+   */
+  async delete(id) {
+    if (isRemote(this.opts)) {
+      await this._fetch("DELETE", `/entities/${encodeURIComponent(id)}`);
+      return;
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    await kernel.deleteEntity(id);
+  }
+  /**
+   * List entities of a given type.
+   */
+  async list(type, opts = {}) {
+    if (isRemote(this.opts)) {
+      const params = new URLSearchParams();
+      if (type) params.set("type", type);
+      if (opts.limit) params.set("limit", String(opts.limit));
+      if (opts.offset) params.set("offset", String(opts.offset));
+      const qs = params.toString() ? `?${params}` : "";
+      return await this._fetch("GET", `/entities${qs}`);
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const entities = kernel.listEntities(type, opts.filters);
+    const limit = opts.limit ?? 100;
+    const offset = opts.offset ?? 0;
+    const page = entities.slice(offset, offset + limit);
+    return {
+      data: page.map(entityToPlain),
+      total: entities.length,
+      limit,
+      offset
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Query
+  // -------------------------------------------------------------------------
+  /**
+   * Run an EQL-S query string.
+   */
+  async query(eql) {
+    if (isRemote(this.opts)) {
+      return await this._fetch("POST", "/query", {
+        query: eql
+      });
+    }
+    const { parseSimple } = await import("./query-XYLTJYSA.js");
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const parsed = parseSimple(eql);
+    return kernel.query(parsed);
+  }
+  // -------------------------------------------------------------------------
+  // File upload
+  // -------------------------------------------------------------------------
+  /**
+   * Upload a file to the blob store.
+   * Returns a content-addressed hash.
+   */
+  async upload(data, contentType = "application/octet-stream") {
+    const raw = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    const cleanBuf = raw.buffer.slice(
+      raw.byteOffset,
+      raw.byteOffset + raw.byteLength
+    );
+    const buffer = new Uint8Array(cleanBuf);
+    if (isRemote(this.opts)) {
+      const res = await fetch(`${this.opts.url}/upload`, {
+        method: "POST",
+        headers: {
+          "Content-Type": contentType,
+          ...this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+        },
+        body: cleanBuf
+      });
+      if (!res.ok) throw new FetchError(res.status, await res.text());
+      return await res.json();
+    }
+    const hashBuf = await crypto.subtle.digest("SHA-256", buffer);
+    const hash = `blob:${Array.from(new Uint8Array(hashBuf)).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const backend = kernel.getBackend();
+    if (!backend.hasBlob(hash)) backend.putBlob(hash, buffer);
+    return { hash, size: buffer.length, contentType };
+  }
+  /**
+   * Download a file by its blob hash.
+   */
+  async getFile(hash) {
+    if (isRemote(this.opts)) {
+      const res = await fetch(
+        `${this.opts.url}/files/${encodeURIComponent(hash)}`,
+        {
+          headers: this.opts.apiKey ? { Authorization: `Bearer ${this.opts.apiKey}` } : {}
+        }
+      );
+      if (res.status === 404) return null;
+      if (!res.ok) throw new FetchError(res.status, await res.text());
+      return new Uint8Array(await res.arrayBuffer());
+    }
+    const pool = this._getPool();
+    const tenantId = this.opts.tenantId ?? null;
+    const kernel = pool.get(tenantId);
+    const backend = kernel.getBackend();
+    return backend.getBlob(hash) ?? null;
+  }
+  // -------------------------------------------------------------------------
+  // Auth helpers
+  // -------------------------------------------------------------------------
+  async register(email, password, name) {
+    if (!isRemote(this.opts))
+      throw new Error("register() requires remote mode");
+    return await this._fetch("POST", "/auth/register", {
+      email,
+      password,
+      name
+    });
+  }
+  async login(email, password) {
+    if (!isRemote(this.opts)) throw new Error("login() requires remote mode");
+    return await this._fetch("POST", "/auth/login", {
+      email,
+      password
+    });
+  }
+  /**
+   * Set the active API key / JWT token for subsequent requests.
+   */
+  setToken(token) {
+    if (!isRemote(this.opts)) return;
+    this.opts.apiKey = token;
+  }
+  // -------------------------------------------------------------------------
+  // Realtime
+  // -------------------------------------------------------------------------
+  /**
+   * Subscribe to a live EQL-S query.
+   * Callback is fired immediately with the initial result, then on every update.
+   *
+   * Requires remote mode (WebSocket to server).
+   */
+  subscribe(eql, callback) {
+    if (!isRemote(this.opts)) {
+      throw new Error(
+        "subscribe() requires remote mode (connect to a running server)"
+      );
+    }
+    const subId = `sub_${crypto.randomUUID()}`;
+    this._subCallbacks.set(subId, callback);
+    this._ensureWs().then((ws) => {
+      ws.send(JSON.stringify({ type: "subscribe", id: subId, query: eql }));
+    });
+    return {
+      unsubscribe: () => {
+        this._subCallbacks.delete(subId);
+        this._ws?.send(JSON.stringify({ type: "unsubscribe", id: subId }));
+      }
+    };
+  }
+  /**
+   * Close the WebSocket connection.
+   */
+  disconnect() {
+    this._ws?.close();
+    this._ws = null;
+  }
+  /**
+   * Close local kernel pool connections.
+   */
+  close() {
+    this._pool?.closeAll();
+    this._pool = null;
+    this.disconnect();
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  _getPool() {
+    if (!this._pool) {
+      const path = this.opts.path;
+      this._pool = new TenantPool(path);
+    }
+    return this._pool;
+  }
+  async _fetch(method, path, body) {
+    const opts = this.opts;
+    const url = `${opts.url}${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    const data = await res.json();
+    if (!res.ok)
+      throw new FetchError(
+        res.status,
+        data?.message ?? res.statusText,
+        data
+      );
+    return data;
+  }
+  async _ensureWs() {
+    if (this._ws && this._ws.readyState === WebSocket.OPEN) return this._ws;
+    const opts = this.opts;
+    const wsUrl = opts.url.replace(/^https?/, opts.url.startsWith("https") ? "wss" : "ws") + "/realtime";
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      ws.onopen = () => {
+        this._ws = ws;
+        resolve(ws);
+      };
+      ws.onerror = (e) => reject(e);
+      ws.onmessage = (e) => {
+        try {
+          const msg = JSON.parse(e.data);
+          if (msg.type === "data" && this._subCallbacks.has(msg.id)) {
+            this._subCallbacks.get(msg.id)(msg.result, msg.diff);
+          }
+        } catch {
+        }
+      };
+      ws.onclose = () => {
+        this._ws = null;
+      };
+    });
+  }
+};
+function entityToPlain(entity) {
+  const obj = { id: entity.id, type: entity.type };
+  for (const f of entity.facts) {
+    if (f.a !== "type") obj[f.a] = f.v;
+  }
+  return obj;
+}
+var FetchError = class extends Error {
+  constructor(status, message, body) {
+    super(`HTTP ${status}: ${message}`);
+    this.status = status;
+    this.body = body;
+    this.name = "FetchError";
+  }
+};
+
+export {
+  TrellisDb,
+  FetchError
+};

package/dist/{index-wt8rz4gn.js → chunk-5JWFAQDW.js}

@@ -1,30 +1,37 @@
-// @bun
 import {
   runSpriteCmd,
   runSpriteCopy
-} from "./index-y6a4kj0p.js";
+} from "./chunk-FF36CQHZ.js";
 import {
   updateConfig
-} from "./index-xzym9w0m.js";
+} from "./chunk-JA7AIHRK.js";
+import {
+  __require
+} from "./chunk-2ESYSVXG.js";
 
 // src/server/deploy.ts
 import { existsSync, writeFileSync, mkdirSync } from "fs";
 import { join, resolve } from "path";
 async function deploy(opts) {
-  const { name, port = 3000, configDir = ".", onProgress = () => {} } = opts;
+  const { name, port = 3e3, configDir = ".", onProgress = () => {
+  } } = opts;
   const apiKey = opts.apiKey ?? generateSecret("spk_");
   const jwtSecret = opts.jwtSecret ?? generateSecret("jws_");
   const url = `https://${name}.sprites.app`;
   onProgress("Checking Sprites CLI...");
   await runSpriteCmd(["--version"]).catch(() => {
-    throw new Error("`sprite` CLI not found. Install it from https://docs.sprites.dev and authenticate.");
+    throw new Error(
+      "`sprite` CLI not found. Install it from https://docs.sprites.dev and authenticate."
+    );
   });
   onProgress("Writing server entrypoint...");
   const tmpDir = resolve(configDir, ".trellis-deploy");
-  if (!existsSync(tmpDir))
-    mkdirSync(tmpDir, { recursive: true });
+  if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });
   const entrypoint = join(tmpDir, "server-entry.ts");
-  writeFileSync(entrypoint, generateServerEntrypoint({ port, apiKey, jwtSecret }));
+  writeFileSync(
+    entrypoint,
+    generateServerEntrypoint({ port, apiKey, jwtSecret })
+  );
   onProgress("Bundling server with Bun...");
   const bundlePath = join(tmpDir, "server.js");
   await runBun([
@@ -55,7 +62,8 @@ async function deploy(opts) {
     "bash",
     "-c",
     "which bun || curl -fsSL https://bun.sh/install | bash"
-  ]).catch(() => {});
+  ]).catch(() => {
+  });
   onProgress("Starting server...");
   await runSpriteCmd([
     "exec",
@@ -64,7 +72,8 @@ async function deploy(opts) {
     "bash",
     "-c",
     "sprite sessions list 2>/dev/null | grep trellis-db | awk '{print $1}' | xargs -r sprite sessions kill"
-  ]).catch(() => {});
+  ]).catch(() => {
+  });
   await runSpriteCmd([
     "exec",
     "--sprite",
@@ -78,13 +87,16 @@ async function deploy(opts) {
     `cd /home/sprite/trellis-db && ~/.bun/bin/bun run server.js`
   ]);
   onProgress("Writing .trellis-db.json...");
-  updateConfig({
-    mode: "remote",
-    url,
-    apiKey,
-    spriteName: name,
-    deployedAt: new Date().toISOString()
-  }, configDir);
+  updateConfig(
+    {
+      mode: "remote",
+      url,
+      apiKey,
+      spriteName: name,
+      deployedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    configDir
+  );
   return { url, name, apiKey };
 }
 function generateSecret(prefix) {
@@ -94,11 +106,15 @@ function generateSecret(prefix) {
   return `${prefix}${b64}`;
 }
 async function runBun(args) {
-  const proc = Bun.spawn(["bun", ...args], { stdout: "pipe", stderr: "pipe" });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const err = await new Response(proc.stderr).text();
-    throw new Error(`bun ${args[0]} failed (exit ${exitCode}): ${err}`);
+  const { execFile } = __require("child_process");
+  const { promisify } = __require("util");
+  const execFileAsync = promisify(execFile);
+  try {
+    await execFileAsync("bun", args);
+  } catch (err) {
+    throw new Error(
+      `bun ${args[0]} failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
   }
 }
 function generateServerEntrypoint(opts) {
@@ -129,4 +145,6 @@ console.log('URL: https://\${process.env.SPRITE_NAME ?? 'localhost'}.sprites.app
 `;
 }
 
-export { deploy };
+export {
+  deploy
+};

package/dist/{index-7pjz3tsy.js → chunk-62UHTVU3.js}

@@ -1,22 +1,17 @@
-// @bun
-import {
-  TrellisKernel
-} from "./index-4wxa8xz4.js";
 import {
   SqliteKernelBackend
-} from "./index-h7zxhhhh.js";
+} from "./chunk-OB4CMMX6.js";
 import {
-  __require
-} from "./index-a76rekgs.js";
+  TrellisKernel
+} from "./chunk-ZE5R3H4C.js";
 
 // src/server/tenancy.ts
 import { existsSync, mkdirSync } from "fs";
 import { join, resolve } from "path";
 var DEFAULT_TENANT = "default";
 var TENANTS_DIR = "tenants";
-
-class TenantPool {
-  pool = new Map;
+var TenantPool = class {
+  pool = /* @__PURE__ */ new Map();
   dbPath;
   agentId;
   backendOpts;
@@ -24,13 +19,24 @@ class TenantPool {
     this.dbPath = resolve(dbPath);
     if (typeof agentIdOrOpts === "string") {
       this.agentId = agentIdOrOpts;
-      this.backendOpts = undefined;
+      this.backendOpts = void 0;
     } else {
       this.agentId = agentIdOrOpts.agentId ?? "trellis-db";
       this.backendOpts = agentIdOrOpts.backend;
     }
     this._ensureDirs();
   }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * Get (or create) the kernel for a tenant.
+   * Pass `null` or `undefined` to get the default tenant.
+   *
+   * Uses the synchronous bun:sqlite backend. To use an async backend
+   * (better-sqlite3, sql.js) call `preload(tenantId)` first; subsequent
+   * `get()` calls will return the preloaded kernel from the pool.
+   */
   get(tenantId) {
     const id = tenantId ?? DEFAULT_TENANT;
     if (!this.pool.has(id)) {
@@ -38,21 +44,37 @@ class TenantPool {
     }
     return this.pool.get(id);
   }
+  /**
+   * Pre-create a tenant's kernel using the runtime-selected backend.
+   * Required when running with an async-only backend (sql.js / WebContainer
+   * / browser). Idempotent — safe to call multiple times.
+   *
+   * After `preload()`, subsequent `get(tenantId)` returns the same kernel
+   * synchronously from the pool.
+   */
   async preload(tenantId) {
     const id = tenantId ?? DEFAULT_TENANT;
     const cached = this.pool.get(id);
-    if (cached)
-      return cached;
+    if (cached) return cached;
     const kernel = await this._createKernelAsync(id);
     this.pool.set(id, kernel);
     return kernel;
   }
+  /**
+   * Check whether a tenant has been initialized (kernel created).
+   */
   has(tenantId) {
     return this.pool.has(tenantId);
   }
+  /**
+   * List all active tenant IDs (those with open kernels).
+   */
   activeTenants() {
     return Array.from(this.pool.keys());
   }
+  /**
+   * Close a specific tenant's kernel and remove it from the pool.
+   */
   close(tenantId) {
     const kernel = this.pool.get(tenantId);
     if (kernel) {
@@ -60,12 +82,18 @@ class TenantPool {
       this.pool.delete(tenantId);
     }
   }
+  /**
+   * Close all kernels and clear the pool.
+   */
   closeAll() {
     for (const kernel of this.pool.values()) {
       kernel.close();
     }
     this.pool.clear();
   }
+  /**
+   * Return the SQLite file path for a given tenant.
+   */
   dbFilePath(tenantId) {
     const id = tenantId ?? DEFAULT_TENANT;
     if (id === DEFAULT_TENANT) {
@@ -73,6 +101,9 @@ class TenantPool {
     }
     return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
   }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
   _createKernelSync(tenantId) {
     const sqlitePath = this.dbFilePath(tenantId);
     const backend = new SqliteKernelBackend(sqlitePath);
@@ -88,7 +119,7 @@ class TenantPool {
     const kernel = new TrellisKernel({
       backend,
       agentId: this.agentId,
-      snapshotThreshold: 1000
+      snapshotThreshold: 1e3
     });
     kernel.boot();
     return kernel;
@@ -102,6 +133,9 @@ class TenantPool {
       mkdirSync(tenantsPath, { recursive: true });
     }
   }
-}
+};
 
-export { DEFAULT_TENANT, TenantPool };
+export {
+  DEFAULT_TENANT,
+  TenantPool
+};

package/dist/{index-h32txmxe.js → chunk-66UJQT2I.js}

@@ -1,19 +1,12 @@
-// @bun
 import {
   __require
-} from "./index-a76rekgs.js";
+} from "./chunk-2ESYSVXG.js";
 
 // src/core/persist/factory.ts
 async function createKernelBackend(dbPath, opts = {}) {
   const choice = opts.backend ?? detectBackend();
-  if (choice === "bun") {
-    const { SqliteKernelBackend } = await import("./sqlite-backend-0vsmc6qj.js");
-    const backend2 = new SqliteKernelBackend(dbPath);
-    backend2.init();
-    return backend2;
-  }
   if (choice === "better-sqlite") {
-    const { BetterSqliteKernelBackend } = await import("./better-sqlite-backend-ahx5p0br.js");
+    const { BetterSqliteKernelBackend } = await import("./better-sqlite-backend-Y3M7DXOX.js");
     const backend2 = new BetterSqliteKernelBackend(dbPath);
     backend2.init();
     return backend2;
@@ -27,16 +20,16 @@ async function createKernelBackend(dbPath, opts = {}) {
   return backend;
 }
 function detectBackend() {
-  if (typeof globalThis.Bun !== "undefined")
-    return "bun";
   try {
     const { createRequire } = __require("module");
     const req = createRequire(import.meta.url);
-    req.resolve("better-sqlite3");
+    req("better-sqlite3");
     return "better-sqlite";
   } catch {
     return "sqljs";
   }
 }
 
-export { createKernelBackend };
+export {
+  createKernelBackend
+};