trellis 3.1.35 → 3.2.2

package/dist/chunk-CAG4FULI.js

@@ -0,0 +1,121 @@
+// src/server/sprites.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runSpriteCmd(args) {
+  try {
+    const { stdout } = await execFileAsync("sprite", args);
+    return stdout.trim();
+  } catch (err) {
+    throw new Error(
+      `sprite ${args[0]} failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
+  }
+}
+async function runSpriteExec(spriteName, shellCommand, extraArgs = []) {
+  return runSpriteCmd([
+    "exec",
+    "-s",
+    spriteName,
+    ...extraArgs,
+    "--",
+    "bash",
+    "-c",
+    shellCommand
+  ]);
+}
+async function runSpriteCopy(localPath, spriteName, remotePath) {
+  try {
+    await execFileAsync("sprite", [
+      "exec",
+      "-s",
+      spriteName,
+      "--file",
+      `${localPath}:${remotePath}`,
+      "echo",
+      "uploaded"
+    ]);
+  } catch (err) {
+    throw new Error(
+      `sprite file upload failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
+  }
+}
+var SPRITE_ENSURE_BUN_SH = `
+set -e
+export PATH="$HOME/.bun/bin:$PATH"
+if ! command -v bun >/dev/null 2>&1; then
+  curl -fsSL https://bun.sh/install | bash
+  export PATH="$HOME/.bun/bin:$PATH"
+fi
+command -v bun
+`.trim();
+function parseSpriteUrlOutput(stdout) {
+  const match = stdout.match(/URL:\s*(https:\/\/\S+)/i);
+  if (!match) {
+    throw new Error(`Could not parse sprite URL from output: ${stdout.trim()}`);
+  }
+  return match[1].replace(/\/$/, "");
+}
+async function resolveSpritePublicUrl(spriteName) {
+  const out = await runSpriteCmd(["url", "-s", spriteName]);
+  return parseSpriteUrlOutput(out);
+}
+async function ensureSpritePublicAccess(spriteName) {
+  try {
+    await runSpriteCmd(["url", "update", "--auth", "public", "-s", spriteName]);
+  } catch (err) {
+    const msg = String(err.message ?? err);
+    if (/already|unchanged|public/i.test(msg)) return;
+    throw err;
+  }
+}
+async function ensureSprite(spriteName) {
+  try {
+    await runSpriteCmd(["create", spriteName, "--skip-console"]);
+  } catch (err) {
+    const msg = String(err.message ?? err);
+    if (/already exists|duplicate|conflict/i.test(msg)) return;
+    throw err;
+  }
+}
+async function runSpriteInteractive(args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("sprite", args, { stdio: "inherit" });
+    proc.on("close", (code) => {
+      if (code !== 0)
+        reject(new Error(`sprite ${args[0]} failed (exit ${code})`));
+      else resolve();
+    });
+    proc.on("error", reject);
+  });
+}
+async function assertSpriteCli() {
+  await runSpriteCmd(["--version"]).catch(() => {
+    throw new Error(
+      "`sprite` CLI not found. Install it from https://docs.sprites.dev and authenticate."
+    );
+  });
+}
+function resolveSprite(explicitName) {
+  if (explicitName) {
+    return explicitName;
+  }
+  throw new Error(
+    "No sprite specified. Use --sprite <name> or set an active sprite with `trellis vm use <name>`"
+  );
+}
+
+export {
+  runSpriteCmd,
+  runSpriteExec,
+  runSpriteCopy,
+  SPRITE_ENSURE_BUN_SH,
+  parseSpriteUrlOutput,
+  resolveSpritePublicUrl,
+  ensureSpritePublicAccess,
+  ensureSprite,
+  runSpriteInteractive,
+  assertSpriteCli,
+  resolveSprite
+};

package/dist/chunk-FF36CQHZ.js

@@ -0,0 +1,61 @@
+// src/server/sprites.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runSpriteCmd(args) {
+  try {
+    const { stdout } = await execFileAsync("sprite", args);
+    return stdout.trim();
+  } catch (err) {
+    throw new Error(
+      `sprite ${args[0]} failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
+  }
+}
+async function runSpriteCopy(localPath, spriteName, remotePath) {
+  try {
+    await execFileAsync("sprite", [
+      "cp",
+      localPath,
+      `${spriteName}:${remotePath}`
+    ]);
+  } catch (err) {
+    throw new Error(
+      `sprite cp failed (exit ${err.code ?? "?"}): ${err.stderr ?? err.message}`
+    );
+  }
+}
+async function runSpriteInteractive(args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("sprite", args, { stdio: "inherit" });
+    proc.on("close", (code) => {
+      if (code !== 0)
+        reject(new Error(`sprite ${args[0]} failed (exit ${code})`));
+      else resolve();
+    });
+    proc.on("error", reject);
+  });
+}
+async function assertSpriteCli() {
+  await runSpriteCmd(["--version"]).catch(() => {
+    throw new Error(
+      "`sprite` CLI not found. Install it from https://docs.sprites.dev and authenticate."
+    );
+  });
+}
+function resolveSprite(explicitName) {
+  if (explicitName) {
+    return explicitName;
+  }
+  throw new Error(
+    "No sprite specified. Use --sprite <name> or set an active sprite with `trellis vm use <name>`"
+  );
+}
+
+export {
+  runSpriteCmd,
+  runSpriteCopy,
+  runSpriteInteractive,
+  assertSpriteCli,
+  resolveSprite
+};

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

@@ -1,19 +1,12 @@
-// @bun
 import {
   __require
-} from "./index-a76rekgs.js";
+} from "./chunk-KFQGP6VL.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-2P4F6AOJ.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
+};

package/dist/{index-nq520y6k.js → chunk-FWRS4CSC.js}

@@ -1,4 +1,3 @@
-// @bun
 import {
   decompose,
   init_blob_store,
@@ -11,12 +10,14 @@ import {
   init_merge,
   init_milestone,
   init_op_log
-} from "./index-xhcp6xrn.js";
+} from "./chunk-VBYUTRXX.js";
+import {
+  init_types
+} from "./chunk-N6MYZT4O.js";
 import {
   init_ops,
-  init_types,
   isVcsOp
-} from "./index-nzb3am4f.js";
+} from "./chunk-GLM4HGN4.js";
 
 // src/vcs/index.ts
 init_types();
@@ -26,8 +27,7 @@ init_decompose();
 // src/vcs/vcs-middleware.ts
 init_decompose();
 init_ops();
-
-class VcsMiddleware {
+var VcsMiddleware = class {
   name = "vcs";
   async handleOp(op, ctx, next) {
     if (!isVcsOp(op)) {
@@ -36,39 +36,51 @@ class VcsMiddleware {
     const vcsOp = op;
     const decomposed = decompose(vcsOp);
     if (decomposed.deleteFacts.length > 0) {
-      await next({
-        ...op,
-        kind: "deleteFacts",
-        facts: decomposed.deleteFacts,
-        links: undefined
-      }, ctx);
+      await next(
+        {
+          ...op,
+          kind: "deleteFacts",
+          facts: decomposed.deleteFacts,
+          links: void 0
+        },
+        ctx
+      );
     }
     if (decomposed.deleteLinks.length > 0) {
-      await next({
-        ...op,
-        kind: "deleteLinks",
-        facts: undefined,
-        links: decomposed.deleteLinks
-      }, ctx);
+      await next(
+        {
+          ...op,
+          kind: "deleteLinks",
+          facts: void 0,
+          links: decomposed.deleteLinks
+        },
+        ctx
+      );
     }
     if (decomposed.addFacts.length > 0) {
-      await next({
-        ...op,
-        kind: "addFacts",
-        facts: decomposed.addFacts,
-        links: undefined
-      }, ctx);
+      await next(
+        {
+          ...op,
+          kind: "addFacts",
+          facts: decomposed.addFacts,
+          links: void 0
+        },
+        ctx
+      );
     }
     if (decomposed.addLinks.length > 0) {
-      await next({
-        ...op,
-        kind: "addLinks",
-        facts: undefined,
-        links: decomposed.addLinks
-      }, ctx);
+      await next(
+        {
+          ...op,
+          kind: "addLinks",
+          facts: void 0,
+          links: decomposed.addLinks
+        },
+        ctx
+      );
     }
   }
-}
+};
 
 // src/vcs/index.ts
 init_blob_store();
@@ -81,4 +93,6 @@ init_issue();
 init_op_log();
 init_lane();
 
-export { VcsMiddleware };
+export {
+  VcsMiddleware
+};

package/dist/chunk-GFZCJ4EH.js

@@ -0,0 +1,108 @@
+// src/realtime/relay-persistence.ts
+var DEFAULT_MAX_CHAT = 200;
+var DEFAULT_MAX_TEXT_OPS = 2e3;
+function chatKey(msg) {
+  return msg.id ?? `${msg.from}:${msg.ts}`;
+}
+function tieKey(msg) {
+  if (msg.t === "msg") return chatKey(msg);
+  if (msg.t === "presence" || msg.t === "bye") return msg.from;
+  return "";
+}
+function messageTs(msg) {
+  if (msg.t === "presence" || msg.t === "bye" || msg.t === "msg") {
+    return msg.ts;
+  }
+  return 0;
+}
+var RelayPersistence = class {
+  maxChat;
+  maxTextOps;
+  presence = /* @__PURE__ */ new Map();
+  /** Chat is a grow-only set keyed by {@link chatKey} — dedup on record. */
+  chatLog = [];
+  chatKeys = /* @__PURE__ */ new Set();
+  textSnapshot = null;
+  textOps = [];
+  constructor(opts = {}) {
+    this.maxChat = opts.maxChat ?? DEFAULT_MAX_CHAT;
+    this.maxTextOps = opts.maxTextOps ?? DEFAULT_MAX_TEXT_OPS;
+  }
+  /** Record an inbound client message (skip `hello` / `replay`). */
+  record(message) {
+    if (message.v !== 1) return;
+    switch (message.t) {
+      case "hello":
+        return;
+      case "replay":
+        return;
+      case "presence":
+        this.presence.set(message.from, message);
+        return;
+      case "bye":
+        this.presence.delete(message.from);
+        return;
+      case "msg":
+        this.recordBroadcast(message);
+        return;
+    }
+  }
+  /** Ordered messages to replay to a peer that just connected. */
+  buildReplay() {
+    const out = [
+      ...this.presence.values(),
+      ...this.chatLog
+    ];
+    if (this.textSnapshot) {
+      out.push(this.textSnapshot);
+    } else {
+      out.push(...this.textOps);
+    }
+    out.sort((a, b) => {
+      const dt = messageTs(a) - messageTs(b);
+      if (dt !== 0) return dt;
+      return tieKey(a).localeCompare(tieKey(b));
+    });
+    return out;
+  }
+  getPresenceCount() {
+    return this.presence.size;
+  }
+  getChatCount() {
+    return this.chatLog.length;
+  }
+  hasTextSnapshot() {
+    return this.textSnapshot !== null;
+  }
+  recordBroadcast(message) {
+    if (message.channel === "chat" && message.event === "message") {
+      const key = chatKey(message);
+      if (this.chatKeys.has(key)) return;
+      this.chatKeys.add(key);
+      this.chatLog.push(message);
+      if (this.chatLog.length > this.maxChat) {
+        const evicted = this.chatLog.splice(0, this.chatLog.length - this.maxChat);
+        for (const m of evicted) this.chatKeys.delete(chatKey(m));
+      }
+      return;
+    }
+    if (message.channel === "text" && message.event === "state") {
+      this.textSnapshot = message;
+      this.textOps = [];
+      return;
+    }
+    if (message.channel === "text" && message.event === "op") {
+      if (this.textSnapshot) return;
+      this.textOps.push(message);
+      if (this.textOps.length > this.maxTextOps) {
+        this.textOps.splice(0, this.textOps.length - this.maxTextOps);
+      }
+    }
+  }
+};
+
+export {
+  DEFAULT_MAX_CHAT,
+  DEFAULT_MAX_TEXT_OPS,
+  RelayPersistence
+};

package/dist/chunk-GLM4HGN4.js

@@ -0,0 +1,55 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/vcs/ops.ts
+async function hashVcsOp(op) {
+  const content = JSON.stringify({
+    kind: op.kind,
+    timestamp: op.timestamp,
+    agentId: op.agentId,
+    previousHash: op.previousHash,
+    vcs: op.vcs
+  });
+  const msgUint8 = new TextEncoder().encode(content);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", msgUint8);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `trellis:op:${hashHex}`;
+}
+async function verifyVcsOpHash(op) {
+  return op.hash === await hashVcsOp(op);
+}
+async function createVcsOp(kind, params) {
+  const opBase = {
+    kind,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    agentId: params.agentId,
+    previousHash: params.previousHash,
+    vcs: params.vcs
+  };
+  return {
+    ...opBase,
+    hash: await hashVcsOp(opBase)
+  };
+}
+function isVcsOp(op) {
+  return op.vcs !== void 0 || typeof op.kind === "string" && op.kind.startsWith("vcs:");
+}
+function isVcsOpKind(kind) {
+  return kind.startsWith("vcs:");
+}
+var init_ops = __esm({
+  "src/vcs/ops.ts"() {
+    "use strict";
+  }
+});
+
+export {
+  hashVcsOp,
+  verifyVcsOpHash,
+  createVcsOp,
+  isVcsOp,
+  isVcsOpKind,
+  init_ops
+};