trellis 3.1.6 → 3.1.7

package/dist/{index-6n5dcebj.js → index-53f3b8p8.js}

@@ -5,10 +5,14 @@ import {
 import {
   QueryEngine
 } from "./index-yp88he8n.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
 
 // src/server/server.ts
 import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 
 // src/server/auth.ts
 var ANONYMOUS = {
@@ -415,7 +419,22 @@ function computeDiff(prev, next) {
 }
 
 // src/server/server.ts
+var __moduleDir = import.meta.dir ?? dirname(fileURLToPath(import.meta.url));
 function startServer(opts) {
+  return startServerBun(opts);
+}
+async function startServerCrossRuntime(opts) {
+  if (typeof globalThis.Bun !== "undefined") {
+    const bunServer = startServerBun(opts);
+    return {
+      port: bunServer.port ?? opts.port ?? opts.config.port ?? 3000,
+      hostname: bunServer.hostname,
+      stop: (closeActive) => bunServer.stop(closeActive)
+    };
+  }
+  return startServerNode(opts);
+}
+function buildServerContext(opts) {
   const { pool, permissions, config } = opts;
   const port = opts.port ?? config.port ?? 3000;
   const authConfig = {
@@ -424,35 +443,42 @@ function startServer(opts) {
     allowPublic: true
   };
   const subs = new SubscriptionManager(pool, permissions ?? null);
-  const server = Bun.serve({
+  const handleHttp = async (req) => {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const auth = await resolveAuth(req.headers.get("authorization"), authConfig);
+    const tenantId = auth.tenantId ?? url.searchParams.get("tenantId") ?? null;
+    try {
+      return await route(req, url, path, auth, tenantId, {
+        pool,
+        permissions: permissions ?? null,
+        subs,
+        authConfig,
+        config,
+        oauthProviders: opts.oauthProviders ?? {}
+      });
+    } catch (err) {
+      if (err instanceof PermissionError) {
+        return json(err.toResponse(), 403);
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      return json({ error: "Internal Server Error", message: msg }, 500);
+    }
+  };
+  return { port, authConfig, subs, handleHttp };
+}
+function startServerBun(opts) {
+  const { port, subs, handleHttp } = buildServerContext(opts);
+  return Bun.serve({
     port,
-    async fetch(req, server2) {
-      const url = new URL(req.url);
-      const path = url.pathname;
+    async fetch(req, server) {
       if (req.headers.get("upgrade") === "websocket") {
-        const upgraded = server2.upgrade(req);
+        const upgraded = server.upgrade(req, { data: undefined });
         if (upgraded)
           return;
         return new Response("WebSocket upgrade failed", { status: 400 });
       }
-      const auth = await resolveAuth(req.headers.get("authorization"), authConfig);
-      const tenantId = auth.tenantId ?? url.searchParams.get("tenantId") ?? null;
-      try {
-        return await route(req, url, path, auth, tenantId, {
-          pool,
-          permissions: permissions ?? null,
-          subs,
-          authConfig,
-          config,
-          oauthProviders: opts.oauthProviders ?? {}
-        });
-      } catch (err) {
-        if (err instanceof PermissionError) {
-          return json(err.toResponse(), 403);
-        }
-        const msg = err instanceof Error ? err.message : String(err);
-        return json({ error: "Internal Server Error", message: msg }, 500);
-      }
+      return handleHttp(req);
     },
     websocket: {
       async open(ws) {
@@ -476,14 +502,42 @@ function startServer(opts) {
       }
     }
   });
-  return server;
+}
+async function startServerNode(opts) {
+  const { port, subs, handleHttp } = buildServerContext(opts);
+  const { startNodeServer } = await import("./server/node-adapter.js");
+  return startNodeServer({
+    port,
+    fetch: handleHttp,
+    websocket: {
+      open(ws) {
+        const id = crypto.randomUUID();
+        ws.__clientId = id;
+        subs.addClient(id, ws, {
+          userId: null,
+          tenantId: null,
+          roles: [],
+          claims: {},
+          authenticated: false
+        }, null);
+      },
+      async message(ws, raw) {
+        const id = ws.__clientId;
+        await subs.handleMessage(id, typeof raw === "string" ? raw : raw.toString());
+      },
+      close(ws) {
+        const id = ws.__clientId;
+        subs.removeClient(id);
+      }
+    }
+  });
 }
 async function route(req, url, path, auth, tenantId, ctx) {
   const method = req.method.toUpperCase();
   if (method === "GET" && path === "/__trellis/inspector.js") {
     const candidates = [
-      join(import.meta.dir, "db", "inspector.js"),
-      join(import.meta.dir, "inspector.js")
+      join(__moduleDir, "db", "inspector.js"),
+      join(__moduleDir, "inspector.js")
     ];
     for (const p of candidates) {
       if (existsSync(p)) {
@@ -498,8 +552,8 @@ async function route(req, url, path, auth, tenantId, ctx) {
   }
   if (method === "GET" && path === "/__trellis/trellis.css") {
     const candidates = [
-      join(import.meta.dir, "db", "trellis.css"),
-      join(import.meta.dir, "trellis.css")
+      join(__moduleDir, "db", "trellis.css"),
+      join(__moduleDir, "trellis.css")
     ];
     for (const p of candidates) {
       if (existsSync(p)) {
@@ -844,4 +898,4 @@ function json(data, status = 200) {
   });
 }
 
-export { ANONYMOUS, signJwt, verifyJwt, resolveAuth, GOOGLE_PROVIDER, GITHUB_PROVIDER, buildOAuthUrl, exchangeOAuthCode, PermissionRegistry, PermissionError, PUBLIC_READ, FULLY_PUBLIC, OWNER_ONLY, ADMIN_ONLY, SubscriptionManager, startServer };
+export { ANONYMOUS, signJwt, verifyJwt, resolveAuth, GOOGLE_PROVIDER, GITHUB_PROVIDER, buildOAuthUrl, exchangeOAuthCode, PermissionRegistry, PermissionError, PUBLIC_READ, FULLY_PUBLIC, OWNER_ONLY, ADMIN_ONLY, SubscriptionManager, startServer, startServerCrossRuntime };

package/dist/{index-y3d71wzd.js → index-7pjz3tsy.js}

@@ -1,8 +1,13 @@
 // @bun
 import {
-  SqliteKernelBackend,
   TrellisKernel
-} from "./index-0zk3fx2s.js";
+} from "./index-4wxa8xz4.js";
+import {
+  SqliteKernelBackend
+} from "./index-h7zxhhhh.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
 
 // src/server/tenancy.ts
 import { existsSync, mkdirSync } from "fs";
@@ -14,18 +19,34 @@ class TenantPool {
   pool = new Map;
   dbPath;
   agentId;
-  constructor(dbPath, agentId = "trellis-db") {
+  backendOpts;
+  constructor(dbPath, agentIdOrOpts = "trellis-db") {
     this.dbPath = resolve(dbPath);
-    this.agentId = agentId;
+    if (typeof agentIdOrOpts === "string") {
+      this.agentId = agentIdOrOpts;
+      this.backendOpts = undefined;
+    } else {
+      this.agentId = agentIdOrOpts.agentId ?? "trellis-db";
+      this.backendOpts = agentIdOrOpts.backend;
+    }
     this._ensureDirs();
   }
   get(tenantId) {
     const id = tenantId ?? DEFAULT_TENANT;
     if (!this.pool.has(id)) {
-      this.pool.set(id, this._createKernel(id));
+      this.pool.set(id, this._createKernelSync(id));
     }
     return this.pool.get(id);
   }
+  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;
+  }
   has(tenantId) {
     return this.pool.has(tenantId);
   }
@@ -52,9 +73,18 @@ class TenantPool {
     }
     return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
   }
-  _createKernel(tenantId) {
+  _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,

package/dist/{index-0q7wbasy.js → index-a2a394zz.js}

@@ -434,9 +434,13 @@ class BlobStore {
     return this.hexFromBuffer(hashBuffer);
   }
   hashSync(content) {
-    const hasher = new Bun.CryptoHasher("sha256");
-    hasher.update(content);
-    return hasher.digest("hex");
+    if (typeof globalThis.Bun !== "undefined") {
+      const hasher = new globalThis.Bun.CryptoHasher("sha256");
+      hasher.update(content);
+      return hasher.digest("hex");
+    }
+    const { createHash } = __require("crypto");
+    return createHash("sha256").update(content).digest("hex");
   }
   count() {
     try {

package/dist/index-h32txmxe.js

@@ -0,0 +1,42 @@
+// @bun
+import {
+  __require
+} from "./index-a76rekgs.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 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() {
+  if (typeof globalThis.Bun !== "undefined")
+    return "bun";
+  try {
+    const { createRequire } = __require("module");
+    const req = createRequire(import.meta.url);
+    req.resolve("better-sqlite3");
+    return "better-sqlite";
+  } catch {
+    return "sqljs";
+  }
+}
+
+export { createKernelBackend };

package/dist/index-h7zxhhhh.js

@@ -0,0 +1,252 @@
+// @bun
+import {
+  __require
+} from "./index-a76rekgs.js";
+
+// src/core/persist/sqlite-backend.ts
+var _DatabaseCtor = null;
+function loadDatabaseCtor() {
+  if (_DatabaseCtor)
+    return _DatabaseCtor;
+  try {
+    const { createRequire } = __require("module");
+    const requireCJS = createRequire(import.meta.url);
+    _DatabaseCtor = requireCJS("bun:sqlite").Database;
+    return _DatabaseCtor;
+  } catch {
+    throw new Error("SqliteKernelBackend requires the Bun runtime (built-in `bun:sqlite`). " + "In Node / WebContainer use `createKernelBackend()` from " + "`trellis/core` \u2014 it auto-selects better-sqlite3 or sql.js.");
+  }
+}
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS ops (
+  hash TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  timestamp TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  previous_hash TEXT,
+  payload TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS snapshots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  last_op_hash TEXT NOT NULL,
+  data TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS blobs (
+  hash TEXT PRIMARY KEY,
+  content BLOB NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_ops_kind ON ops(kind);
+CREATE INDEX IF NOT EXISTS idx_ops_timestamp ON ops(timestamp);
+CREATE INDEX IF NOT EXISTS idx_ops_agent ON ops(agent_id);
+CREATE INDEX IF NOT EXISTS idx_ops_previous ON ops(previous_hash);
+CREATE INDEX IF NOT EXISTS idx_snapshots_op ON snapshots(last_op_hash);
+`;
+
+class SqliteKernelBackend {
+  dbPath;
+  db;
+  _stmts = null;
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    const DatabaseCtor = loadDatabaseCtor();
+    this.db = new DatabaseCtor(dbPath);
+  }
+  init() {
+    this.db.exec("PRAGMA journal_mode=WAL;");
+    this.db.exec("PRAGMA foreign_keys=ON;");
+    this.db.exec("PRAGMA synchronous=NORMAL;");
+    this.db.exec(SCHEMA_SQL);
+    this._prepareStatements();
+  }
+  _prepareStatements() {
+    this._stmts = {
+      insert: this.db.prepare(`
+        INSERT OR IGNORE INTO ops (hash, kind, timestamp, agent_id, previous_hash, payload)
+        VALUES ($hash, $kind, $timestamp, $agentId, $previousHash, $payload)
+      `),
+      readAll: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops ORDER BY rowid ASC
+      `),
+      readUntil: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops WHERE rowid <= (SELECT rowid FROM ops WHERE hash = $hash)
+        ORDER BY rowid ASC
+      `),
+      readAfter: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops WHERE rowid > (SELECT rowid FROM ops WHERE hash = $hash)
+        ORDER BY rowid ASC
+      `),
+      getByHash: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops WHERE hash = $hash
+      `),
+      getLast: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops ORDER BY rowid DESC LIMIT 1
+      `),
+      count: this.db.prepare("SELECT COUNT(*) as cnt FROM ops"),
+      saveSnapshot: this.db.prepare(`
+        INSERT INTO snapshots (last_op_hash, data)
+        VALUES ($lastOpHash, $data)
+      `),
+      loadSnapshot: this.db.prepare(`
+        SELECT last_op_hash, data FROM snapshots
+        ORDER BY id DESC LIMIT 1
+      `),
+      putBlob: this.db.prepare(`
+        INSERT OR IGNORE INTO blobs (hash, content) VALUES ($hash, $content)
+      `),
+      getBlob: this.db.prepare(`
+        SELECT content FROM blobs WHERE hash = $hash
+      `),
+      hasBlob: this.db.prepare(`
+        SELECT 1 FROM blobs WHERE hash = $hash
+      `)
+    };
+  }
+  append(op) {
+    const payload = JSON.stringify({
+      facts: op.facts,
+      links: op.links,
+      ...op.deleteFacts?.length ? { deleteFacts: op.deleteFacts } : {},
+      ...op.deleteLinks?.length ? { deleteLinks: op.deleteLinks } : {},
+      ...op.vcs ? { vcs: op.vcs } : {},
+      ...op.signature ? { signature: op.signature } : {}
+    });
+    this._stmts.insert.run({
+      $hash: op.hash,
+      $kind: op.kind,
+      $timestamp: op.timestamp,
+      $agentId: op.agentId,
+      $previousHash: op.previousHash ?? null,
+      $payload: payload
+    });
+  }
+  appendBatch(ops) {
+    if (ops.length === 0)
+      return;
+    this.db.transaction(() => {
+      for (const op of ops) {
+        this.append(op);
+      }
+    })();
+  }
+  readAll() {
+    const rows = this._stmts.readAll.all();
+    return rows.map(rowToOp);
+  }
+  readUntil(hash) {
+    const rows = this._stmts.readUntil.all({ $hash: hash });
+    return rows.map(rowToOp);
+  }
+  readAfter(hash) {
+    const rows = this._stmts.readAfter.all({ $hash: hash });
+    return rows.map(rowToOp);
+  }
+  readUntilTimestamp(isoTimestamp) {
+    const rows = this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+         FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`).all({ $ts: isoTimestamp });
+    return rows.map(rowToOp);
+  }
+  getLastOp() {
+    const row = this._stmts.getLast.get();
+    return row ? rowToOp(row) : undefined;
+  }
+  getByHash(hash) {
+    return this.getOpByHash(hash);
+  }
+  getOpCount() {
+    return this.count();
+  }
+  getOpByHash(hash) {
+    const row = this._stmts.getByHash.get({ $hash: hash });
+    return row ? rowToOp(row) : undefined;
+  }
+  count() {
+    const row = this._stmts.count.get();
+    return row?.cnt ?? 0;
+  }
+  findCommonAncestor(hashA, hashB) {
+    const ancestorsA = new Set;
+    let cursor = hashA;
+    while (cursor) {
+      ancestorsA.add(cursor);
+      const op = this.getOpByHash(cursor);
+      cursor = op?.previousHash;
+    }
+    cursor = hashB;
+    while (cursor) {
+      if (ancestorsA.has(cursor)) {
+        return this.getOpByHash(cursor);
+      }
+      const op = this.getOpByHash(cursor);
+      cursor = op?.previousHash;
+    }
+    return;
+  }
+  saveSnapshot(lastOpHash, data) {
+    this._stmts.saveSnapshot.run({
+      $lastOpHash: lastOpHash,
+      $data: JSON.stringify(data)
+    });
+  }
+  loadLatestSnapshot() {
+    const row = this._stmts.loadSnapshot.get();
+    if (!row)
+      return;
+    return {
+      lastOpHash: row.last_op_hash,
+      data: JSON.parse(row.data)
+    };
+  }
+  putBlob(hash, content) {
+    this._stmts.putBlob.run({
+      $hash: hash,
+      $content: Buffer.from(content)
+    });
+  }
+  getBlob(hash) {
+    const row = this._stmts.getBlob.get({ $hash: hash });
+    if (!row)
+      return;
+    return new Uint8Array(row.content);
+  }
+  hasBlob(hash) {
+    return !!this._stmts.hasBlob.get({ $hash: hash });
+  }
+  close() {
+    this.db.close();
+  }
+}
+function rowToOp(row) {
+  const payload = JSON.parse(row.payload);
+  const op = {
+    hash: row.hash,
+    kind: row.kind,
+    timestamp: row.timestamp,
+    agentId: row.agent_id
+  };
+  if (row.previous_hash)
+    op.previousHash = row.previous_hash;
+  if (payload.facts)
+    op.facts = payload.facts;
+  if (payload.links)
+    op.links = payload.links;
+  if (payload.deleteFacts)
+    op.deleteFacts = payload.deleteFacts;
+  if (payload.deleteLinks)
+    op.deleteLinks = payload.deleteLinks;
+  if (payload.vcs)
+    op.vcs = payload.vcs;
+  if (payload.signature)
+    op.signature = payload.signature;
+  return op;
+}
+
+export { SqliteKernelBackend };