trellis 3.1.35 → 3.2.2

package/dist/chunk-6GEZ6DN5.js

@@ -0,0 +1,394 @@
+import {
+  TrellisVcsEngine,
+  init_engine
+} from "./chunk-L5N5PR2S.js";
+import {
+  IdbOpLog
+} from "./chunk-MPXUVGT3.js";
+import {
+  JsonOpLog,
+  init_op_log
+} from "./chunk-VBYUTRXX.js";
+import {
+  PartyKitRoomTransport,
+  TrellisVcsSyncPeer
+} from "./chunk-RSWUFTO2.js";
+import {
+  Signal
+} from "./chunk-UBGUDMUV.js";
+
+// src/client/vcs-client.ts
+init_engine();
+init_op_log();
+var DEFAULT_SYNC_STATUS = {
+  connected: false,
+  pending: 0,
+  synced: false,
+  lastSyncAt: null,
+  lastError: null
+};
+var MemoryOpLog = class {
+  ops = [];
+  hashes = /* @__PURE__ */ new Set();
+  load() {
+  }
+  append(op) {
+    if (this.hashes.has(op.hash)) return;
+    this.ops.push(op);
+    this.hashes.add(op.hash);
+  }
+  readAll() {
+    return [...this.ops];
+  }
+  getLastOp() {
+    return this.ops[this.ops.length - 1];
+  }
+  count() {
+    return this.ops.length;
+  }
+};
+var TrellisClient = class _TrellisClient {
+  _engine;
+  _syncPeer;
+  _peerId = "";
+  _opLog;
+  _roomId = "room";
+  _pushDebounceMs = 200;
+  _snapshotMaxOps = 500;
+  _pushTimer;
+  _closed = false;
+  /** Raw causal log. Updated on every local or remote op. */
+  _ops = new Signal([]);
+  /** Sync connection state. */
+  _syncStatus = new Signal({ ...DEFAULT_SYNC_STATUS });
+  _opHandlers = [];
+  _topicSubs = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  /** Factory — opens the repo, loads ops, and optionally connects to sync. */
+  static async open(opts) {
+    const client = new _TrellisClient();
+    client._peerId = opts.agentId ?? `client:${crypto.randomUUID()}`;
+    client._opLog = client._createOpLog(opts);
+    if ("load" in client._opLog && typeof client._opLog.load === "function") {
+      const maybePromise = client._opLog.load();
+      if (maybePromise instanceof Promise) await maybePromise;
+    }
+    client._engine = new TrellisVcsEngine({
+      rootPath: opts.repo,
+      agentId: client._peerId,
+      opLog: client._opLog
+    });
+    client._engine.open();
+    client._refreshState();
+    if (opts.sync) {
+      client._roomId = opts.sync.roomId ?? "room";
+      client._pushDebounceMs = opts.sync.pushDebounceMs ?? 200;
+      client._snapshotMaxOps = opts.sync.snapshotMaxOps ?? 500;
+      const transport = client._createTransport(opts.sync, client);
+      client._syncPeer = new TrellisVcsSyncPeer({
+        peerId: client._peerId,
+        engine: client._engine,
+        transport,
+        onIntegrate: () => {
+          client._refreshState();
+          client._setSyncStatus({ synced: true, lastError: null });
+        }
+      });
+      if (opts.sync.connectOnOpen !== false) {
+        try {
+          await client._connectAndCatchUp();
+        } catch {
+        }
+      }
+    }
+    return client;
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /** Subscribe to reactive topics. Callback receives current value immediately. */
+  subscribe(topic, callback) {
+    if (!this._topicSubs.has(topic)) {
+      this._topicSubs.set(topic, /* @__PURE__ */ new Set());
+    }
+    const subs = this._topicSubs.get(topic);
+    subs.add(callback);
+    const current = this._getTopicValue(topic);
+    if (current !== void 0) {
+      try {
+        callback(current);
+      } catch {
+      }
+    }
+    return () => {
+      subs.delete(callback);
+    };
+  }
+  /** Listen for raw op events (local or remote). */
+  on(event, handler) {
+    this._opHandlers.push(handler);
+    return () => {
+      const idx = this._opHandlers.indexOf(handler);
+      if (idx >= 0) this._opHandlers.splice(idx, 1);
+    };
+  }
+  /** Create an issue and emit reactive updates. */
+  async createIssue(title, opts) {
+    const createOpts = { ...opts };
+    if (opts?.lane) {
+      createOpts.laneId = opts.lane;
+    }
+    const op = await this._engine.createIssue(title, createOpts);
+    this._refreshState();
+    this._schedulePush();
+    return op;
+  }
+  /** Force a push/pull sync with the room. */
+  async sync() {
+    if (!this._syncPeer) {
+      throw new Error(
+        "No sync configured. Pass sync.url to TrellisClient.open() to enable multiplayer sync."
+      );
+    }
+    await this._connectAndCatchUp();
+  }
+  /** Close (complete) an issue. */
+  async closeIssue(id, opts) {
+    const result = await this._engine.closeIssue(id, opts);
+    if (result.op) {
+      this._refreshState();
+      this._schedulePush();
+    }
+    return result.op ?? null;
+  }
+  /** Reopen a closed issue. */
+  async reopenIssue(id) {
+    const op = await this._engine.reopenIssue(id);
+    this._refreshState();
+    this._schedulePush();
+    return op;
+  }
+  /** Read current ops without subscribing. */
+  getOps() {
+    return this._engine.getOps();
+  }
+  /** Read current issues without subscribing. */
+  listIssues() {
+    return this._engine.listIssues();
+  }
+  /** Clean up resources. */
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._pushTimer !== void 0) {
+      clearTimeout(this._pushTimer);
+      this._pushTimer = void 0;
+    }
+    this._syncPeer?.close();
+    if ("close" in this._opLog && typeof this._opLog.close === "function") {
+      void this._opLog.close();
+    }
+    this._engine.stop();
+    this._setSyncStatus({ connected: false });
+  }
+  // -------------------------------------------------------------------------
+  // Reactive accessors (for framework adapters)
+  // -------------------------------------------------------------------------
+  /** Signal exposing the full causal op log. */
+  get opsSignal() {
+    return this._ops;
+  }
+  /** Signal exposing sync connection status. */
+  get syncStatusSignal() {
+    return this._syncStatus;
+  }
+  /** Underlying VCS engine (for advanced sync wiring and queries). */
+  get engine() {
+    return this._engine;
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  _createTransport(sync, client) {
+    if (sync.transport) return sync.transport;
+    if (!sync.url) {
+      throw new Error(
+        "sync.transport or sync.url is required when sync is configured."
+      );
+    }
+    return new PartyKitRoomTransport({
+      peerId: this._peerId,
+      roomUrl: sync.url,
+      auth: sync.auth,
+      roomId: sync.roomId,
+      reconnect: sync.reconnect !== false,
+      onReconnect: () => client._onTransportReconnect(),
+      onDisconnect: () => client._setSyncStatus({ connected: false })
+    });
+  }
+  _createOpLog(opts) {
+    switch (opts.persist) {
+      case "indexeddb":
+        return new IdbOpLog({ dbName: opts.repo });
+      case "memory":
+        return new MemoryOpLog();
+      case "opfs":
+        throw new Error(
+          'OPFS persistence not yet implemented. Use "indexeddb" or "memory".'
+        );
+      default:
+        if (typeof globalThis !== "undefined" && "indexedDB" in globalThis) {
+          return new IdbOpLog({ dbName: opts.repo });
+        }
+        return new JsonOpLog(`${opts.repo}/.trellis/ops.json`);
+    }
+  }
+  async _connectTransport() {
+    const transport = this._syncPeer?.getTransport();
+    if (transport && "connect" in transport && typeof transport.connect === "function") {
+      await transport.connect();
+      this._setSyncStatus({ connected: true, lastError: null });
+    } else if (transport) {
+      this._setSyncStatus({ connected: true, lastError: null });
+    }
+  }
+  async _connectAndCatchUp() {
+    if (!this._syncPeer) return;
+    this._setSyncStatus({
+      pending: this._syncStatus.value.pending + 1,
+      synced: false
+    });
+    try {
+      await this._connectTransport();
+      await this._requestSnapshot();
+      const result = await this._syncPeer.syncWith(this._roomId);
+      this._setSyncStatus({
+        connected: true,
+        synced: result.rejected === 0,
+        lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastError: result.rejected > 0 ? `${result.rejected} op(s) rejected during sync` : null
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._setSyncStatus({
+        connected: false,
+        synced: false,
+        lastError: message
+      });
+      throw err;
+    } finally {
+      this._setSyncStatus({
+        pending: Math.max(0, this._syncStatus.value.pending - 1)
+      });
+    }
+  }
+  async _onTransportReconnect() {
+    if (this._closed || !this._syncPeer) return;
+    try {
+      await this._connectAndCatchUp();
+    } catch {
+    }
+  }
+  async _requestSnapshot() {
+    if (!this._syncPeer || this._snapshotMaxOps <= 0) return;
+    await this._syncPeer.requestSnapshot(this._roomId, this._snapshotMaxOps);
+    await new Promise((resolve) => {
+      queueMicrotask(() => resolve());
+    });
+  }
+  _schedulePush() {
+    if (!this._syncPeer || this._pushDebounceMs <= 0 || this._closed) return;
+    if (this._pushTimer !== void 0) {
+      clearTimeout(this._pushTimer);
+    }
+    this._pushTimer = setTimeout(() => {
+      this._pushTimer = void 0;
+      void this._pushToRoom();
+    }, this._pushDebounceMs);
+  }
+  async _pushToRoom() {
+    if (!this._syncPeer || this._closed) return;
+    this._setSyncStatus({
+      pending: this._syncStatus.value.pending + 1,
+      synced: false
+    });
+    try {
+      await this._connectTransport();
+      const result = await this._syncPeer.pushTo(this._roomId);
+      this._setSyncStatus({
+        connected: true,
+        synced: result.remoteRejected.length === 0,
+        lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastError: result.remoteRejected.length > 0 ? `${result.remoteRejected.length} op(s) rejected by room` : null
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._setSyncStatus({
+        connected: false,
+        synced: false,
+        lastError: message
+      });
+    } finally {
+      this._setSyncStatus({
+        pending: Math.max(0, this._syncStatus.value.pending - 1)
+      });
+    }
+  }
+  _refreshState() {
+    const ops = this._engine.getOps();
+    const previousHashes = new Set(this._ops.value.map((o) => o.hash));
+    this._ops.value = ops;
+    for (const op of ops) {
+      if (!previousHashes.has(op.hash)) {
+        this._emitOp(op);
+      }
+    }
+    this._broadcastTopic("ops", ops);
+    this._broadcastTopic("issues", this._engine.listIssues());
+    this._broadcastTopic("milestones", this._engine.listMilestones());
+    this._broadcastTopic("branches", this._engine.listBranches());
+  }
+  _emitOp(op) {
+    for (const h of this._opHandlers) {
+      try {
+        h(op);
+      } catch {
+      }
+    }
+  }
+  _broadcastTopic(topic, data) {
+    const subs = this._topicSubs.get(topic);
+    if (!subs) return;
+    for (const fn of subs) {
+      try {
+        fn(data);
+      } catch {
+      }
+    }
+  }
+  _getTopicValue(topic) {
+    switch (topic) {
+      case "ops":
+        return this._ops.value;
+      case "syncStatus":
+        return this._syncStatus.value;
+      case "issues":
+        return this._engine.listIssues();
+      case "milestones":
+        return this._engine.listMilestones();
+      case "branches":
+        return this._engine.listBranches();
+      default:
+        return void 0;
+    }
+  }
+  _setSyncStatus(partial) {
+    this._syncStatus.value = { ...this._syncStatus.value, ...partial };
+    this._broadcastTopic("syncStatus", this._syncStatus.value);
+  }
+};
+
+export {
+  TrellisClient
+};

package/dist/chunk-7ZFRVCUE.js

@@ -0,0 +1,211 @@
+import {
+  SPRITE_ENSURE_BUN_SH,
+  assertSpriteCli,
+  ensureSprite,
+  ensureSpritePublicAccess,
+  resolveSpritePublicUrl,
+  runSpriteCopy,
+  runSpriteExec
+} from "./chunk-CAG4FULI.js";
+import {
+  updateConfig
+} from "./chunk-JA7AIHRK.js";
+import {
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// src/server/deploy.ts
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+
+// src/server/deploy-meta.ts
+var DEPLOY_NAME_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var MIN_LEN = 3;
+var MAX_LEN = 32;
+var DeployNameError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeployNameError";
+  }
+};
+function normalizeDeployName(name) {
+  return name.trim().toLowerCase();
+}
+function validateDeployName(name) {
+  const normalized = normalizeDeployName(name);
+  if (!normalized) {
+    throw new DeployNameError("Deploy name is required.");
+  }
+  if (normalized.length < MIN_LEN || normalized.length > MAX_LEN) {
+    throw new DeployNameError(
+      `Deploy name must be ${MIN_LEN}\u2013${MAX_LEN} characters (got ${normalized.length}).`
+    );
+  }
+  if (normalized.includes("--")) {
+    throw new DeployNameError(
+      "Deploy name cannot contain consecutive hyphens."
+    );
+  }
+  if (!DEPLOY_NAME_RE.test(normalized)) {
+    throw new DeployNameError(
+      "Deploy name must start with a letter and use only lowercase letters, numbers, and single hyphens (e.g. my-app)."
+    );
+  }
+  return normalized;
+}
+function buildDeployUrl(name) {
+  const slug = validateDeployName(name);
+  return `https://${slug}.sprites.app`;
+}
+var SPRITE_PUBLIC_HTTP_PORT = 8080;
+
+// src/server/deploy.ts
+async function deploy(opts) {
+  const { configDir = ".", onProgress = () => {
+  } } = opts;
+  const listenPort = opts.port ?? SPRITE_PUBLIC_HTTP_PORT;
+  const name = validateDeployName(opts.name);
+  const apiKey = opts.apiKey ?? generateSecret("spk_");
+  const jwtSecret = opts.jwtSecret ?? generateSecret("jws_");
+  if (opts.stub) {
+    const url2 = buildDeployUrl(name);
+    onProgress("Stub deploy \u2014 skipping Sprites provisioning");
+    onProgress("Writing .trellis-db.json...");
+    writeRemoteDeployConfig({ name, url: url2, apiKey, configDir });
+    return { url: url2, name, apiKey };
+  }
+  onProgress("Checking Sprites CLI...");
+  await assertSpriteCli();
+  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: listenPort, apiKey, jwtSecret })
+  );
+  onProgress("Bundling server with Bun...");
+  const bundlePath = join(tmpDir, "server.js");
+  await runBun([
+    "build",
+    entrypoint,
+    "--outfile",
+    bundlePath,
+    "--target",
+    "bun",
+    "--format",
+    "esm"
+  ]);
+  onProgress(`Ensuring Sprite: ${name}...`);
+  await ensureSprite(name);
+  onProgress("Configuring public URL...");
+  await ensureSpritePublicAccess(name);
+  const url = await resolveSpritePublicUrl(name);
+  onProgress(`Uploading to Sprite: ${name}...`);
+  await runSpriteExec(name, "mkdir -p /home/sprite/trellis-db");
+  await runSpriteCopy(bundlePath, name, "/home/sprite/trellis-db/server.js");
+  onProgress("Ensuring Bun is installed...");
+  const bunPath = await runSpriteExec(name, SPRITE_ENSURE_BUN_SH);
+  if (!bunPath.includes("bun")) {
+    throw new Error(`Bun install failed on sprite ${name}: ${bunPath || "(no output)"}`);
+  }
+  onProgress("Starting server...");
+  await runSpriteExec(
+    name,
+    'pkill -f "/home/sprite/trellis-db/server.js" 2>/dev/null || true'
+  ).catch(() => {
+  });
+  const bun = bunPath.trim().split("\n").pop().trim();
+  await runSpriteExec(
+    name,
+    `cd /home/sprite/trellis-db && (nohup ${bun} run server.js >> server.log 2>&1 </dev/null &); exit 0`
+  );
+  onProgress("Waiting for health check...");
+  await waitForDeployHealth(url, 6e4);
+  onProgress("Writing .trellis-db.json...");
+  writeRemoteDeployConfig({ name, url, apiKey, configDir });
+  return { url, name, apiKey };
+}
+function writeRemoteDeployConfig(opts) {
+  updateConfig(
+    {
+      mode: "remote",
+      url: opts.url,
+      apiKey: opts.apiKey,
+      spriteName: opts.name,
+      deployedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    opts.configDir
+  );
+}
+async function waitForDeployHealth(url, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const healthUrl = `${url.replace(/\/$/, "")}/health`;
+  let lastStatus = 0;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(healthUrl);
+      lastStatus = res.status;
+      if (res.ok) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  throw new Error(
+    `Deploy health check timed out (${healthUrl}${lastStatus ? `, last status ${lastStatus}` : ""})`
+  );
+}
+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';
+
+writeConfig(defaultLocalConfig(dbPath, {
+  apiKey: '${opts.apiKey}',
+  jwtSecret: '${opts.jwtSecret}',
+  port: ${opts.port},
+}), configDir);
+
+const config = readConfig(configDir)!;
+// Sprites VMs lack better-sqlite3 native bindings \u2014 use WASM sql.js backend.
+const pool = new TenantPool(dbPath, { backend: { backend: 'sqljs' } });
+await pool.preload();
+
+const server = startServer({ port: ${opts.port}, config, pool });
+
+console.log('Trellis DB running on port ${opts.port}');
+console.log(\`Listening on port ${opts.port}\`);
+`;
+}
+
+export {
+  DeployNameError,
+  normalizeDeployName,
+  validateDeployName,
+  buildDeployUrl,
+  SPRITE_PUBLIC_HTTP_PORT,
+  deploy
+};