trellis 3.1.35 → 3.2.0

package/dist/chunk-BJ5EKCJ5.js

@@ -0,0 +1,458 @@
+import {
+  init_reconciler,
+  reconcile
+} from "./chunk-4HYPLFJD.js";
+
+// src/sync/types.ts
+var PROTOCOL_VERSION = 1;
+var MIN_SUPPORTED_VERSION = 1;
+var MAX_SUPPORTED_VERSION = 1;
+
+// src/sync/sync-engine.ts
+init_reconciler();
+var SyncEngine = class {
+  localPeerId;
+  state;
+  transport;
+  getLocalOps;
+  onOpsReceived;
+  onNackReceived;
+  branchPolicy;
+  constructor(opts) {
+    this.localPeerId = opts.localPeerId;
+    this.transport = opts.transport;
+    this.getLocalOps = opts.getLocalOps;
+    this.onOpsReceived = opts.onOpsReceived;
+    this.onNackReceived = opts.onNackReceived;
+    this.branchPolicy = opts.branchPolicy ?? { linear: true };
+    this.state = {
+      localPeerId: opts.localPeerId,
+      peerHeads: /* @__PURE__ */ new Map(),
+      pendingAcks: /* @__PURE__ */ new Set(),
+      lastSync: /* @__PURE__ */ new Map()
+    };
+    this.transport.onMessage((msg) => this.handleMessage(msg));
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * Initiate a sync with a specific peer.
+   * Sends a 'have' message advertising our heads.
+   */
+  async pushTo(peerId) {
+    const ops = this.getLocalOps();
+    const heads = {};
+    if (ops.length > 0) {
+      heads["main"] = ops[ops.length - 1].hash;
+    }
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "have",
+      peerId: this.localPeerId,
+      heads,
+      opCount: ops.length
+    });
+  }
+  /**
+   * Request ops from a peer.
+   */
+  async pullFrom(peerId) {
+    const ops = this.getLocalOps();
+    const lastHash = ops.length > 0 ? ops[ops.length - 1].hash : void 0;
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "want",
+      peerId: this.localPeerId,
+      wantHashes: [],
+      afterHash: lastHash
+    });
+  }
+  /**
+   * Request the peer's complete op set and rely on hash dedupe during ingest.
+   */
+  async pullAllFrom(peerId) {
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "want",
+      peerId: this.localPeerId,
+      wantHashes: []
+    });
+  }
+  /**
+   * Send all our ops to a peer (full push).
+   */
+  async sendOps(peerId, ops) {
+    const opsToSend = ops ?? this.getLocalOps();
+    await this.sendOpsMessage(peerId, opsToSend);
+  }
+  /**
+   * Internal: send an `ops` message and track outbound hashes in
+   * `pendingAcks` until the receiver acks or nacks them. All three sites
+   * that emit `ops` (sendOps, handleHave, handleWant) route through here so
+   * pendingAcks reflects every outbound op uniformly.
+   */
+  async sendOpsMessage(peerId, ops) {
+    if (ops.length === 0) return;
+    for (const op of ops) {
+      this.state.pendingAcks.add(op.hash);
+    }
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "ops",
+      peerId: this.localPeerId,
+      ops
+    });
+  }
+  /**
+   * Reconcile our ops with a remote peer's ops.
+   */
+  reconcileWith(remoteOps) {
+    const localOps = this.getLocalOps();
+    return reconcile(localOps, remoteOps);
+  }
+  /**
+   * Get current sync state.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get branch policy.
+   */
+  getBranchPolicy() {
+    return this.branchPolicy;
+  }
+  /**
+   * Set branch policy.
+   */
+  setBranchPolicy(policy) {
+    this.branchPolicy = policy;
+  }
+  /**
+   * List known peers.
+   */
+  listPeers() {
+    return this.transport.peers();
+  }
+  // -------------------------------------------------------------------------
+  // Message handling
+  // -------------------------------------------------------------------------
+  async handleMessage(msg) {
+    if (typeof msg.version !== "number" || msg.version < MIN_SUPPORTED_VERSION || msg.version > MAX_SUPPORTED_VERSION) {
+      await this.transport.send(msg.peerId, {
+        version: PROTOCOL_VERSION,
+        type: "nack",
+        peerId: this.localPeerId,
+        refs: [],
+        reason: "protocol-version",
+        details: `Unsupported protocol version ${msg.version}; supported range is ${MIN_SUPPORTED_VERSION}-${MAX_SUPPORTED_VERSION}.`
+      });
+      return;
+    }
+    switch (msg.type) {
+      case "have":
+        await this.handleHave(msg);
+        break;
+      case "want":
+        await this.handleWant(msg);
+        break;
+      case "ops":
+        await this.handleOps(msg);
+        break;
+      case "ack":
+        this.handleAck(msg);
+        break;
+      case "nack":
+        await this.handleNack(msg);
+        break;
+    }
+  }
+  async handleHave(msg) {
+    this.state.peerHeads.set(msg.peerId, msg.heads);
+    const localOps = this.getLocalOps();
+    const localHashes = new Set(localOps.map((o) => o.hash));
+    for (const [, hash] of Object.entries(msg.heads)) {
+      if (!localHashes.has(hash)) {
+        const afterHash = msg.opCount > localOps.length ? void 0 : localOps.length > 0 ? localOps[localOps.length - 1].hash : void 0;
+        await this.transport.send(msg.peerId, {
+          version: PROTOCOL_VERSION,
+          type: "want",
+          peerId: this.localPeerId,
+          wantHashes: [],
+          afterHash
+        });
+        return;
+      }
+    }
+    if (msg.opCount > localOps.length) {
+      await this.transport.send(msg.peerId, {
+        version: PROTOCOL_VERSION,
+        type: "want",
+        peerId: this.localPeerId,
+        wantHashes: []
+      });
+      return;
+    }
+    const peerOpCount = msg.opCount;
+    if (localOps.length > peerOpCount) {
+      await this.sendOpsMessage(msg.peerId, localOps.slice(peerOpCount));
+    }
+  }
+  async handleWant(msg) {
+    const localOps = this.getLocalOps();
+    let opsToSend;
+    if (msg.afterHash) {
+      const idx = localOps.findIndex((o) => o.hash === msg.afterHash);
+      opsToSend = idx >= 0 ? localOps.slice(idx + 1) : localOps;
+    } else if (msg.wantHashes.length > 0) {
+      const wanted = new Set(msg.wantHashes);
+      opsToSend = localOps.filter((o) => wanted.has(o.hash));
+    } else {
+      opsToSend = localOps;
+    }
+    await this.sendOpsMessage(msg.peerId, opsToSend);
+  }
+  async handleOps(msg) {
+    if (msg.ops.length === 0) return;
+    let result;
+    if (this.branchPolicy.linear) {
+      const localOps = this.getLocalOps();
+      const localHashes = new Set(localOps.map((o) => o.hash));
+      const newOps = msg.ops.filter((o) => !localHashes.has(o.hash));
+      if (newOps.length > 0) {
+        result = await this.onOpsReceived(newOps) ?? void 0;
+      }
+    } else {
+      const reconciled = this.reconcileWith(msg.ops);
+      if (reconciled.uniqueToB.length > 0) {
+        result = await this.onOpsReceived(reconciled.uniqueToB) ?? void 0;
+      }
+    }
+    const rejections = result?.rejections ?? [];
+    if (rejections.length > 0) {
+      const byReason = /* @__PURE__ */ new Map();
+      for (const r of rejections) {
+        const entry = byReason.get(r.reason) ?? {
+          refs: [],
+          details: r.details
+        };
+        entry.refs.push(r.hash);
+        byReason.set(r.reason, entry);
+      }
+      for (const [reason, entry] of byReason) {
+        await this.transport.send(msg.peerId, {
+          version: PROTOCOL_VERSION,
+          type: "nack",
+          peerId: this.localPeerId,
+          refs: entry.refs,
+          reason,
+          details: entry.details
+        });
+      }
+    }
+    const rejectedSet = new Set(rejections.map((r) => r.hash));
+    const ackHashes = msg.ops.map((o) => o.hash).filter((h) => !rejectedSet.has(h));
+    if (ackHashes.length > 0) {
+      await this.transport.send(msg.peerId, {
+        version: PROTOCOL_VERSION,
+        type: "ack",
+        peerId: this.localPeerId,
+        integrated: ackHashes
+      });
+    }
+    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  handleAck(msg) {
+    for (const hash of msg.integrated) {
+      this.state.pendingAcks.delete(hash);
+    }
+    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async handleNack(msg) {
+    for (const ref of msg.refs) {
+      this.state.pendingAcks.delete(ref);
+    }
+    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
+    if (this.onNackReceived) {
+      await this.onNackReceived(msg);
+    }
+  }
+};
+
+// src/sync/vcs-sync-peer.ts
+var TrellisVcsSyncPeer = class {
+  engine;
+  syncEngine;
+  integrationResults = [];
+  remoteNacks = [];
+  constructor(opts) {
+    this.engine = opts.engine;
+    this.syncEngine = new SyncEngine({
+      localPeerId: opts.peerId,
+      transport: opts.transport,
+      getLocalOps: () => this.engine.getOps(),
+      onOpsReceived: async (ops) => {
+        const result = await this.engine.integrateOps(ops);
+        this.integrationResults.push(result);
+        await opts.onIntegrate?.(result);
+        const rejections = result.rejected.map(
+          (r) => ({
+            hash: r.op.hash,
+            reason: r.reason,
+            details: r.message
+          })
+        );
+        return { rejections };
+      },
+      onNackReceived: async (nack) => {
+        const info = {
+          peerId: nack.peerId,
+          reason: nack.reason,
+          refs: nack.refs,
+          details: nack.details
+        };
+        this.remoteNacks.push(info);
+        await opts.onRemoteNack?.(nack);
+      },
+      branchPolicy: opts.branchPolicy
+    });
+  }
+  async pushTo(peerId) {
+    return this.captureSync(peerId, () => this.syncEngine.pushTo(peerId));
+  }
+  async pullFrom(peerId) {
+    return this.captureSync(peerId, () => this.syncEngine.pullAllFrom(peerId));
+  }
+  async syncWith(peerId) {
+    return this.captureSync(peerId, async () => {
+      await this.syncEngine.pushTo(peerId);
+      await this.syncEngine.pullAllFrom(peerId);
+    });
+  }
+  listPeers() {
+    return this.syncEngine.listPeers();
+  }
+  getSyncEngine() {
+    return this.syncEngine;
+  }
+  /**
+   * Cumulative nacks received from remote peers since construction.
+   * Useful for tests and for consumers that want to inspect the full history.
+   * Sync results returned by `pushTo`/`pullFrom`/`syncWith` already include
+   * the per-session slice in `remoteRejected`.
+   */
+  getRemoteNacks() {
+    return this.remoteNacks;
+  }
+  async captureSync(peerId, run) {
+    const beforeOpCount = this.engine.getOpCount();
+    const start = this.integrationResults.length;
+    const nackStart = this.remoteNacks.length;
+    await run();
+    const batches = this.integrationResults.slice(start);
+    const remoteRejected = this.remoteNacks.slice(nackStart);
+    const afterOpCount = this.engine.getOpCount();
+    return {
+      peerId,
+      beforeOpCount,
+      afterOpCount,
+      batches,
+      applied: batches.reduce((sum, batch) => sum + batch.applied, 0),
+      skipped: batches.reduce((sum, batch) => sum + batch.skipped, 0),
+      rejected: batches.reduce(
+        (sum, batch) => sum + batch.rejected.length,
+        0
+      ),
+      remoteRejected
+    };
+  }
+};
+
+// src/sync/partykit-transport.ts
+var PartyKitRoomTransport = class {
+  peerId;
+  room;
+  roomUrl;
+  WebSocketImpl;
+  ws = null;
+  messageHandler = null;
+  constructor(opts) {
+    this.peerId = opts.peerId;
+    this.roomUrl = opts.roomUrl;
+    this.room = {
+      id: opts.roomId ?? "room",
+      name: opts.roomName ?? opts.roomId ?? "room"
+    };
+    const WebSocketGlobal = globalThis.WebSocket;
+    const WebSocketImpl = opts.WebSocketImpl ?? WebSocketGlobal;
+    if (!WebSocketImpl) {
+      throw new Error(
+        "PartyKitRoomTransport requires WebSocket or opts.WebSocketImpl."
+      );
+    }
+    this.WebSocketImpl = WebSocketImpl;
+  }
+  async connect() {
+    if (this.ws?.readyState === 1) return;
+    await new Promise((resolve, reject) => {
+      const ws = new this.WebSocketImpl(this.roomUrl);
+      this.ws = ws;
+      ws.onopen = () => resolve();
+      ws.onerror = (event) => {
+        reject(new Error(`PartyKit room connection failed: ${String(event)}`));
+      };
+      ws.onmessage = async (event) => {
+        const message = this.parseMessage(event.data);
+        if (!message || !this.messageHandler) return;
+        await this.messageHandler(message);
+      };
+      ws.onclose = () => {
+        if (this.ws === ws) {
+          this.ws = null;
+        }
+      };
+    });
+  }
+  async send(peerId, message) {
+    if (peerId !== this.room.id) {
+      throw new Error(`PartyKitRoomTransport can only send to ${this.room.id}.`);
+    }
+    await this.connect();
+    this.ws.send(JSON.stringify(message));
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  peers() {
+    return [this.room];
+  }
+  close() {
+    this.ws?.close();
+    this.ws = null;
+  }
+  getPeerId() {
+    return this.peerId;
+  }
+  getRoomPeer() {
+    return { ...this.room };
+  }
+  parseMessage(data) {
+    try {
+      const raw = typeof data === "string" ? data : String(data);
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed.type === "string" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+export {
+  PROTOCOL_VERSION,
+  MIN_SUPPORTED_VERSION,
+  MAX_SUPPORTED_VERSION,
+  SyncEngine,
+  TrellisVcsSyncPeer,
+  PartyKitRoomTransport
+};

package/dist/chunk-BJ7EZ7FP.js

@@ -0,0 +1,145 @@
+import {
+  attachStandardMiddleware
+} from "./chunk-SPSPV5BC.js";
+import {
+  SqliteKernelBackend
+} from "./chunk-XMQ7G77X.js";
+import {
+  TrellisKernel
+} from "./chunk-KQ4A2D2P.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();
+    attachStandardMiddleware(kernel);
+    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
+};