trellis 3.2.0 → 3.2.3

package/dist/chunk-5IQZFITY.js

@@ -1,357 +0,0 @@
-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/chunk-5JWFAQDW.js

@@ -1,150 +0,0 @@
-import {
-  runSpriteCmd,
-  runSpriteCopy
-} from "./chunk-FF36CQHZ.js";
-import {
-  updateConfig
-} 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 = 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."
-    );
-  });
-  onProgress("Writing server entrypoint...");
-  const tmpDir = resolve(configDir, ".trellis-deploy");
-  if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });
-  const entrypoint = join(tmpDir, "server-entry.ts");
-  writeFileSync(
-    entrypoint,
-    generateServerEntrypoint({ port, apiKey, jwtSecret })
-  );
-  onProgress("Bundling server with Bun...");
-  const bundlePath = join(tmpDir, "server.js");
-  await runBun([
-    "build",
-    entrypoint,
-    "--outfile",
-    bundlePath,
-    "--target",
-    "bun",
-    "--format",
-    "esm"
-  ]);
-  onProgress(`Uploading to Sprite: ${name}...`);
-  await runSpriteCmd([
-    "exec",
-    "--sprite",
-    name,
-    "mkdir",
-    "-p",
-    "/home/sprite/trellis-db"
-  ]);
-  await runSpriteCopy(bundlePath, name, "/home/sprite/trellis-db/server.js");
-  onProgress("Ensuring Bun is installed...");
-  await runSpriteCmd([
-    "exec",
-    "--sprite",
-    name,
-    "bash",
-    "-c",
-    "which bun || curl -fsSL https://bun.sh/install | bash"
-  ]).catch(() => {
-  });
-  onProgress("Starting server...");
-  await runSpriteCmd([
-    "exec",
-    "--sprite",
-    name,
-    "bash",
-    "-c",
-    "sprite sessions list 2>/dev/null | grep trellis-db | awk '{print $1}' | xargs -r sprite sessions kill"
-  ]).catch(() => {
-  });
-  await runSpriteCmd([
-    "exec",
-    "--sprite",
-    name,
-    "-tty",
-    "--detach",
-    "--session-name",
-    "trellis-db",
-    "bash",
-    "-c",
-    `cd /home/sprite/trellis-db && ~/.bun/bin/bun run server.js`
-  ]);
-  onProgress("Writing .trellis-db.json...");
-  updateConfig(
-    {
-      mode: "remote",
-      url,
-      apiKey,
-      spriteName: name,
-      deployedAt: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    configDir
-  );
-  return { url, name, apiKey };
-}
-function generateSecret(prefix) {
-  const bytes = new Uint8Array(24);
-  crypto.getRandomValues(bytes);
-  const b64 = btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-  return `${prefix}${b64}`;
-}
-async function runBun(args) {
-  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) {
-  return `
-import { TenantPool, startServer } from 'trellis/server';
-import { readConfig, defaultLocalConfig, writeConfig } from 'trellis/client';
-import { join } from 'path';
-import { existsSync } from 'fs';
-
-const dbPath = '/home/sprite/trellis-db/data';
-const configDir = '/home/sprite/trellis-db';
-
-if (!existsSync(join(configDir, '.trellis-db.json'))) {
-  writeConfig(defaultLocalConfig(dbPath, {
-    apiKey: '${opts.apiKey}',
-    jwtSecret: '${opts.jwtSecret}',
-    port: ${opts.port},
-  }), configDir);
-}
-
-const config = readConfig(configDir)!;
-const pool = new TenantPool(dbPath);
-
-const server = startServer({ port: ${opts.port}, config, pool });
-
-console.log('Trellis DB running on port ${opts.port}');
-console.log('URL: https://\${process.env.SPRITE_NAME ?? 'localhost'}.sprites.app');
-`;
-}
-
-export {
-  deploy
-};

package/dist/chunk-62UHTVU3.js

@@ -1,141 +0,0 @@
-import {
-  SqliteKernelBackend
-} from "./chunk-OB4CMMX6.js";
-import {
-  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";
-var TenantPool = class {
-  pool = /* @__PURE__ */ new Map();
-  dbPath;
-  agentId;
-  backendOpts;
-  constructor(dbPath, agentIdOrOpts = "trellis-db") {
-    this.dbPath = resolve(dbPath);
-    if (typeof agentIdOrOpts === "string") {
-      this.agentId = agentIdOrOpts;
-      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)) {
-      this.pool.set(id, this._createKernelSync(id));
-    }
-    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;
-    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) {
-      kernel.close();
-      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) {
-      return join(this.dbPath, "default.sqlite");
-    }
-    return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
-  }
-  // -------------------------------------------------------------------------
-  // Private
-  // -------------------------------------------------------------------------
-  _createKernelSync(tenantId) {
-    const sqlitePath = this.dbFilePath(tenantId);
-    const backend = new SqliteKernelBackend(sqlitePath);
-    return this._wrapKernel(backend);
-  }
-  async _createKernelAsync(tenantId) {
-    const sqlitePath = this.dbFilePath(tenantId);
-    const { createKernelBackend } = await import("./core/persist/factory.js");
-    const backend = await createKernelBackend(sqlitePath, this.backendOpts);
-    return this._wrapKernel(backend);
-  }
-  _wrapKernel(backend) {
-    const kernel = new TrellisKernel({
-      backend,
-      agentId: this.agentId,
-      snapshotThreshold: 1e3
-    });
-    kernel.boot();
-    return kernel;
-  }
-  _ensureDirs() {
-    if (!existsSync(this.dbPath)) {
-      mkdirSync(this.dbPath, { recursive: true });
-    }
-    const tenantsPath = join(this.dbPath, TENANTS_DIR);
-    if (!existsSync(tenantsPath)) {
-      mkdirSync(tenantsPath, { recursive: true });
-    }
-  }
-};
-
-export {
-  DEFAULT_TENANT,
-  TenantPool
-};

package/dist/chunk-66UJQT2I.js

@@ -1,35 +0,0 @@
-import {
-  __require
-} from "./chunk-2ESYSVXG.js";
-
-// src/core/persist/factory.ts
-async function createKernelBackend(dbPath, opts = {}) {
-  const choice = opts.backend ?? detectBackend();
-  if (choice === "better-sqlite") {
-    const { BetterSqliteKernelBackend } = await import("./better-sqlite-backend-Y3M7DXOX.js");
-    const backend2 = new BetterSqliteKernelBackend(dbPath);
-    backend2.init();
-    return backend2;
-  }
-  const { SqlJsKernelBackend } = await import("./core/persist/sqljs-backend.js");
-  const backend = await SqlJsKernelBackend.create({
-    dbPath,
-    autoFlushEvery: opts.sqljs?.autoFlushEvery
-  });
-  backend.init();
-  return backend;
-}
-function detectBackend() {
-  try {
-    const { createRequire } = __require("module");
-    const req = createRequire(import.meta.url);
-    req("better-sqlite3");
-    return "better-sqlite";
-  } catch {
-    return "sqljs";
-  }
-}
-
-export {
-  createKernelBackend
-};