@cryptiklemur/lattice 1.26.1 → 1.27.0

package/.github/workflows/release.yml

@@ -16,6 +16,9 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     environment: npm
+    outputs:
+      new_release_published: ${{ steps.semantic.outputs.new_release_published }}
+      new_release_version: ${{ steps.semantic.outputs.new_release_version }}
     steps:
       - name: Checkout
         uses: actions/checkout@v5
@@ -39,6 +42,46 @@ jobs:
         run: bun run build
 
       - name: Release
+        id: semantic
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npx semantic-release
+        run: |
+          npx semantic-release
+          TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+          if [ -n "$TAG" ]; then
+            VERSION="${TAG#v}"
+            echo "new_release_published=true" >> $GITHUB_OUTPUT
+            echo "new_release_version=$VERSION" >> $GITHUB_OUTPUT
+          else
+            echo "new_release_published=false" >> $GITHUB_OUTPUT
+          fi
+
+  build-binaries:
+    name: Build ${{ matrix.target }}
+    needs: release
+    if: needs.release.outputs.new_release_published == 'true'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [linux-x64, linux-arm64, darwin-x64, darwin-arm64]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+        with:
+          ref: v${{ needs.release.outputs.new_release_version }}
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Build binary
+        run: bun scripts/build-binary.ts --target=${{ matrix.target }} --version=${{ needs.release.outputs.new_release_version }}
+
+      - name: Upload to GitHub Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh release upload "v${{ needs.release.outputs.new_release_version }}" "dist/lattice-${{ matrix.target }}" --clobber

package/client/src/components/sidebar/UserIsland.tsx

@@ -1,11 +1,13 @@
-import { useState } from "react";
-import { Sun, Moon, Settings, Download } from "lucide-react";
+import { useState, useEffect } from "react";
+import { Sun, Moon, Settings, Download, ArrowUpCircle } from "lucide-react";
 import { useStore } from "@tanstack/react-store";
 import { useTheme } from "../../hooks/useTheme";
 import { useSidebar } from "../../hooks/useSidebar";
 import { useInstallPrompt } from "../../hooks/useInstallPrompt";
+import { useWebSocket } from "../../hooks/useWebSocket";
 import { getSessionStore } from "../../stores/session";
 import pkg from "../../../package.json";
+import type { ServerMessage } from "@lattice/shared";
 
 interface UserIslandProps {
   nodeName: string;
@@ -18,6 +20,20 @@ export function UserIsland(props: UserIslandProps) {
   var { canInstall, install } = useInstallPrompt();
   var budgetStatus = useStore(getSessionStore(), function (s) { return s.budgetStatus; });
   var [showTooltip, setShowTooltip] = useState(false);
+  var ws = useWebSocket();
+  var [updateAvailable, setUpdateAvailable] = useState(false);
+  var [latestVersion, setLatestVersion] = useState<string | null>(null);
+
+  useEffect(function () {
+    function handleUpdateStatus(msg: ServerMessage) {
+      if (msg.type !== "update:status") return;
+      var data = msg as { type: string; updateAvailable: boolean; latestVersion: string | null };
+      setUpdateAvailable(data.updateAvailable);
+      setLatestVersion(data.latestVersion);
+    }
+    ws.subscribe("update:status", handleUpdateStatus);
+    return function () { ws.unsubscribe("update:status", handleUpdateStatus); };
+  }, []);
 
   var initial = props.nodeName.charAt(0).toUpperCase();
 
@@ -72,8 +88,14 @@ export function UserIsland(props: UserIslandProps) {
             <div className="text-[13px] font-semibold text-base-content truncate">
               {props.nodeName}
             </div>
-            <div className="text-[10px] text-base-content/30 font-mono">
-              {"v" + pkg.version}
+            <div className="text-[10px] font-mono flex items-center gap-1">
+              <span className="text-base-content/30">{"v" + pkg.version}</span>
+              {updateAvailable && latestVersion && (
+                <span className="flex items-center gap-0.5 text-primary/70">
+                  <ArrowUpCircle size={9} />
+                  {latestVersion}
+                </span>
+              )}
             </div>
           </div>
         </button>

package/client/src/components/ui/UpdateBanner.tsx

@@ -0,0 +1,110 @@
+import { useState, useEffect } from "react";
+import { ArrowUpCircle, X, Loader2, ExternalLink, RefreshCw } from "lucide-react";
+import { useWebSocket } from "../../hooks/useWebSocket";
+import type { ServerMessage } from "@lattice/shared";
+
+interface UpdateState {
+  currentVersion: string;
+  latestVersion: string | null;
+  updateAvailable: boolean;
+  releaseUrl: string | null;
+}
+
+export function UpdateBanner() {
+  var { send, subscribe, unsubscribe } = useWebSocket();
+  var [update, setUpdate] = useState<UpdateState | null>(null);
+  var [dismissed, setDismissed] = useState(false);
+  var [applying, setApplying] = useState(false);
+  var [applyResult, setApplyResult] = useState<{ success: boolean; message: string } | null>(null);
+
+  useEffect(function () {
+    function handleStatus(msg: ServerMessage) {
+      if (msg.type !== "update:status") return;
+      var data = msg as UpdateState & { type: string };
+      setUpdate({ currentVersion: data.currentVersion, latestVersion: data.latestVersion, updateAvailable: data.updateAvailable, releaseUrl: data.releaseUrl });
+      if (data.updateAvailable) setDismissed(false);
+    }
+
+    function handleApplyResult(msg: ServerMessage) {
+      if (msg.type !== "update:apply_result") return;
+      var data = msg as { type: string; success: boolean; message?: string };
+      setApplying(false);
+      setApplyResult({ success: data.success, message: data.message ?? "" });
+    }
+
+    subscribe("update:status", handleStatus);
+    subscribe("update:apply_result", handleApplyResult);
+    send({ type: "update:check" } as any);
+
+    return function () {
+      unsubscribe("update:status", handleStatus);
+      unsubscribe("update:apply_result", handleApplyResult);
+    };
+  }, []);
+
+  if (!update || !update.updateAvailable || dismissed) return null;
+
+  if (applyResult) {
+    return (
+      <div className={
+        "flex items-center gap-2 px-4 py-2 text-[12px] border-b " +
+        (applyResult.success
+          ? "bg-success/10 border-success/20 text-success"
+          : "bg-error/10 border-error/20 text-error")
+      }>
+        <span className="flex-1">{applyResult.message}</span>
+        {applyResult.success && (
+          <button
+            onClick={function () { window.location.reload(); }}
+            className="flex items-center gap-1 text-[11px] font-mono font-bold hover:underline"
+          >
+            <RefreshCw size={11} />
+            Reload
+          </button>
+        )}
+        <button onClick={function () { setDismissed(true); }} className="btn btn-ghost btn-xs btn-square opacity-50 hover:opacity-100">
+          <X size={12} />
+        </button>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex items-center gap-2 px-4 py-2 bg-primary/8 border-b border-primary/15 text-[12px] text-base-content/70">
+      <ArrowUpCircle size={14} className="text-primary flex-shrink-0" />
+      <span className="flex-1">
+        <span className="font-semibold text-base-content">v{update.latestVersion}</span>
+        {" "}available
+        <span className="text-base-content/40 ml-1">(current: v{update.currentVersion})</span>
+      </span>
+      {update.releaseUrl && (
+        <a
+          href={update.releaseUrl}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="flex items-center gap-0.5 text-[11px] text-primary/50 hover:text-primary transition-colors"
+        >
+          <ExternalLink size={10} />
+          Notes
+        </a>
+      )}
+      {applying ? (
+        <Loader2 size={12} className="text-primary animate-spin" />
+      ) : (
+        <button
+          onClick={function () { setApplying(true); send({ type: "update:apply" } as any); }}
+          className="btn btn-primary btn-xs"
+        >
+          Update
+        </button>
+      )}
+      <button
+        onClick={function () { setDismissed(true); }}
+        aria-label="Dismiss update"
+        className="btn btn-ghost btn-xs btn-square text-base-content/30 hover:text-base-content"
+      >
+        <X size={12} />
+      </button>
+    </div>
+  );
+}

package/client/src/router.tsx

@@ -15,6 +15,7 @@ import { AddProjectModal } from "./components/sidebar/AddProjectModal";
 import { useSidebar } from "./hooks/useSidebar";
 import { useWorkspace } from "./hooks/useWorkspace";
 import { useWebSocket } from "./hooks/useWebSocket";
+import { UpdateBanner } from "./components/ui/UpdateBanner";
 import { useSwipeDrawer } from "./hooks/useSwipeDrawer";
 import { exitSettings, getSidebarStore, handlePopState, closeDrawer, toggleDrawer } from "./stores/sidebar";
 
@@ -422,6 +423,7 @@ function RootLayout() {
         />
 
         <main id="main-content" className="drawer-content flex flex-col h-full min-w-0 overflow-hidden">
+          <UpdateBanner />
           <Outlet />
         </main>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "1.26.1",
+  "version": "1.27.0",
   "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
   "license": "MIT",
   "author": "Aaron Scherer <me@aaronscherer.me>",
@@ -29,7 +29,9 @@
     "dev": "bun run --filter '*' dev",
     "build": "bun run --filter '*' build",
     "lint": "bun run --filter '*' lint",
-    "typecheck": "bunx tsc --noEmit -p tsconfig.json"
+    "typecheck": "bunx tsc --noEmit -p tsconfig.json",
+    "build:binary": "bun scripts/build-binary.ts",
+    "build:binary:all": "bun scripts/build-binary.ts --all"
   },
   "workspaces": [
     "shared",

package/scripts/build-binary.ts

@@ -0,0 +1,157 @@
+#!/usr/bin/env bun
+import { readdirSync, readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from "node:fs";
+import { join, extname, relative } from "node:path";
+import { execSync } from "node:child_process";
+
+var CONTENT_TYPES: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".webmanifest": "application/manifest+json",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".txt": "text/plain",
+  ".map": "application/json",
+  ".wasm": "application/wasm",
+};
+
+var VALID_TARGETS = ["linux-x64", "linux-arm64", "darwin-x64", "darwin-arm64"];
+
+var ROOT = join(import.meta.dir, "..");
+
+function parseArgs(): { targets: string[]; version: string } {
+  var args = process.argv.slice(2);
+  var targets: string[] = [];
+  var version = "";
+
+  for (var i = 0; i < args.length; i++) {
+    if (args[i] === "--target" && i + 1 < args.length) {
+      targets.push(args[i + 1]);
+      i++;
+    } else if (args[i].startsWith("--target=")) {
+      targets.push(args[i].split("=")[1]);
+    } else if (args[i] === "--version" && i + 1 < args.length) {
+      version = args[i + 1];
+      i++;
+    } else if (args[i].startsWith("--version=")) {
+      version = args[i].split("=")[1];
+    } else if (args[i] === "--all") {
+      targets = [...VALID_TARGETS];
+    }
+  }
+
+  if (targets.length === 0) {
+    var platform = process.platform === "darwin" ? "darwin" : "linux";
+    var arch = process.arch === "arm64" ? "arm64" : "x64";
+    targets = [platform + "-" + arch];
+  }
+
+  if (!version) {
+    var pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf-8"));
+    version = pkg.version || "0.0.0-dev";
+  }
+
+  for (var t = 0; t < targets.length; t++) {
+    if (VALID_TARGETS.indexOf(targets[t]) === -1) {
+      console.error("Invalid target: " + targets[t]);
+      console.error("Valid targets: " + VALID_TARGETS.join(", "));
+      process.exit(1);
+    }
+  }
+
+  return { targets, version };
+}
+
+function walkDir(dir: string, base: string): Array<{ path: string; relativePath: string }> {
+  var results: Array<{ path: string; relativePath: string }> = [];
+  var entries = readdirSync(dir, { withFileTypes: true });
+  for (var i = 0; i < entries.length; i++) {
+    var fullPath = join(dir, entries[i].name);
+    if (entries[i].isDirectory()) {
+      results = results.concat(walkDir(fullPath, base));
+    } else {
+      results.push({ path: fullPath, relativePath: "/" + relative(base, fullPath) });
+    }
+  }
+  return results;
+}
+
+function generateEmbeddedAssets(clientDistDir: string): void {
+  console.log("[build] Generating embedded assets...");
+  var files = walkDir(clientDistDir, clientDistDir);
+  var genDir = join(ROOT, "server/src/_generated");
+  mkdirSync(genDir, { recursive: true });
+
+  var lines: string[] = [];
+  lines.push("var assets = new Map<string, { b64: string; type: string }>();");
+
+  var totalSize = 0;
+  for (var i = 0; i < files.length; i++) {
+    var file = files[i];
+    var ext = extname(file.path);
+    var contentType = CONTENT_TYPES[ext] || "application/octet-stream";
+    var data = readFileSync(file.path);
+    var b64 = data.toString("base64");
+    totalSize += data.length;
+    lines.push("assets.set(" + JSON.stringify(file.relativePath) + ", { b64: " + JSON.stringify(b64) + ", type: " + JSON.stringify(contentType) + " });");
+  }
+
+  lines.push("export { assets };");
+
+  writeFileSync(join(genDir, "embedded-assets.ts"), lines.join("\n"), "utf-8");
+  console.log("[build] Embedded " + files.length + " files (" + (totalSize / 1024 / 1024).toFixed(1) + " MB)");
+}
+
+function buildClient(): void {
+  console.log("[build] Building client...");
+  execSync("bun run --filter @lattice/client build", { cwd: ROOT, stdio: "inherit" });
+}
+
+function compileBinary(target: string, version: string): void {
+  var outDir = join(ROOT, "dist");
+  mkdirSync(outDir, { recursive: true });
+  var outFile = join(outDir, "lattice-" + target);
+
+  console.log("[build] Compiling for " + target + "...");
+  var cmd = [
+    "bun", "build", "--compile",
+    "--target=bun-" + target,
+    "--outfile=" + outFile,
+    "--define=process.env.LATTICE_VERSION=\"'" + version + "'\"",
+    join(ROOT, "server/src/index.ts"),
+  ].join(" ");
+
+  execSync(cmd, { cwd: ROOT, stdio: "inherit" });
+
+  var size = statSync(outFile).size;
+  console.log("[build] Output: " + outFile + " (" + (size / 1024 / 1024).toFixed(1) + " MB)");
+}
+
+function main(): void {
+  var { targets, version } = parseArgs();
+  console.log("[build] Version: " + version);
+  console.log("[build] Targets: " + targets.join(", "));
+
+  buildClient();
+
+  var clientDist = join(ROOT, "client/dist");
+  if (!existsSync(clientDist)) {
+    console.error("[build] client/dist not found after build");
+    process.exit(1);
+  }
+
+  generateEmbeddedAssets(clientDist);
+
+  for (var i = 0; i < targets.length; i++) {
+    compileBinary(targets[i], version);
+  }
+
+  console.log("[build] Done.");
+}
+
+main();

package/server/src/assets.ts

@@ -0,0 +1,69 @@
+import { join } from "node:path";
+import { IS_COMPILED } from "./runtime";
+
+var CONTENT_TYPES: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".webmanifest": "application/manifest+json",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".txt": "text/plain",
+  ".map": "application/json",
+  ".wasm": "application/wasm",
+};
+
+interface EmbeddedAssetModule {
+  assets: Map<string, { b64: string; type: string }>;
+}
+
+var embeddedAssets: Map<string, { b64: string; type: string }> | null = null;
+var assetCache = new Map<string, Uint8Array>();
+
+export async function initAssets(): Promise<void> {
+  if (!IS_COMPILED) return;
+  try {
+    var mod = await import("./_generated/embedded-assets") as EmbeddedAssetModule;
+    embeddedAssets = mod.assets;
+  } catch {}
+}
+
+export function serveStaticAsset(pathname: string): Response | null {
+  if (!embeddedAssets) return null;
+
+  var entry = embeddedAssets.get(pathname);
+  if (!entry) return null;
+
+  var cached = assetCache.get(pathname);
+  if (!cached) {
+    cached = Buffer.from(entry.b64, "base64") as unknown as Uint8Array;
+    assetCache.set(pathname, cached);
+  }
+
+  return new Response(cached as unknown as BodyInit, {
+    headers: {
+      "Content-Type": entry.type,
+      "Cache-Control": pathname === "/index.html" || pathname === "/sw.js"
+        ? "no-cache"
+        : "public, max-age=31536000, immutable",
+    },
+  });
+}
+
+export function hasEmbeddedAssets(): boolean {
+  return embeddedAssets !== null;
+}
+
+export function getClientDir(): string {
+  return join(import.meta.dir, "../../client/dist");
+}
+
+export function guessContentType(path: string): string {
+  var ext = path.slice(path.lastIndexOf("."));
+  return CONTENT_TYPES[ext] || "application/octet-stream";
+}

package/server/src/daemon.ts

@@ -1,4 +1,5 @@
 import { join, resolve } from "node:path";
+import { initAssets, serveStaticAsset, hasEmbeddedAssets, getClientDir } from "./assets";
 import { readFileSync, existsSync } from "node:fs";
 import type { ServerWebSocket } from "bun";
 import { getLatticeHome, loadConfig } from "./config";
@@ -35,8 +36,10 @@ import "./handlers/editor";
 import "./handlers/analytics";
 import "./handlers/bookmarks";
 import "./handlers/plugins";
+import "./handlers/update";
 import { startScheduler } from "./features/scheduler";
 import { loadNotes } from "./features/sticky-notes";
+import { startPeriodicUpdateCheck, getCachedUpdateInfo } from "./update-checker";
 import { loadBookmarks } from "./project/bookmarks";
 import { cleanupClientTerminals } from "./handlers/terminal";
 import { cleanupClient as cleanupClientAttachments } from "./handlers/attachment";
@@ -202,7 +205,8 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
   log.server("Node: %s (%s)", config.name, identity.id);
   log.server("Home: %s", getLatticeHome());
 
-  var clientDir = join(import.meta.dir, "../../client/dist");
+  await initAssets();
+  var clientDir = getClientDir();
 
   var tlsOptions: { cert: Buffer; key: Buffer } | undefined;
   if (config.tls) {
@@ -286,6 +290,15 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
       }
 
       var staticPath = url.pathname === "/" ? "/index.html" : url.pathname;
+
+      if (hasEmbeddedAssets()) {
+        var embedded = serveStaticAsset(staticPath);
+        if (embedded) return embedded;
+        var embeddedIndex = serveStaticAsset("/index.html");
+        if (embeddedIndex) return embeddedIndex;
+        return new Response("Not found", { status: 404 });
+      }
+
       var file = Bun.file(join(clientDir, staticPath));
       if (await file.exists()) {
         return new Response(file);
@@ -355,6 +368,8 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
   loadNotes();
   loadBookmarks();
 
+  startPeriodicUpdateCheck();
+
   loadInterruptedSessions();
 
   onPeerConnected(function (nodeId: string) {
@@ -386,5 +401,16 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
         return { slug: p.slug, path: p.path, title: p.title, nodeId: currentIdentity.id, nodeName: currentConfig.name, isRemote: false, ideProjectName: detectIdeProjectName(p.path) };
       }),
     });
+    var updateInfo = getCachedUpdateInfo();
+    if (updateInfo && updateInfo.updateAvailable) {
+      broadcast({
+        type: "update:status",
+        currentVersion: updateInfo.currentVersion,
+        latestVersion: updateInfo.latestVersion,
+        updateAvailable: updateInfo.updateAvailable,
+        releaseUrl: updateInfo.releaseUrl,
+        installMode: updateInfo.installMode,
+      });
+    }
   }, 10000);
 }

package/server/src/handlers/update.ts

@@ -0,0 +1,127 @@
+import { chmodSync, renameSync, writeFileSync } from "node:fs";
+import type { ClientMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo, broadcast } from "../ws/broadcast";
+import { checkForUpdate, getPackageName, getGitHubRepo, getInstallMode } from "../update-checker";
+import { IS_COMPILED } from "../runtime";
+
+function getAssetName(): string {
+  var platform = process.platform === "darwin" ? "darwin" : "linux";
+  var arch = process.arch === "arm64" ? "arm64" : "x64";
+  return "lattice-" + platform + "-" + arch;
+}
+
+async function downloadBinaryUpdate(): Promise<{ success: boolean; message: string }> {
+  var repo = getGitHubRepo();
+  var assetName = getAssetName();
+
+  try {
+    var releaseRes = await fetch("https://api.github.com/repos/" + repo + "/releases/latest", {
+      headers: { "Accept": "application/vnd.github.v3+json" },
+      signal: AbortSignal.timeout(30000),
+    });
+
+    if (!releaseRes.ok) {
+      return { success: false, message: "Failed to fetch release info (HTTP " + releaseRes.status + ")" };
+    }
+
+    var release = await releaseRes.json() as { assets?: Array<{ name: string; browser_download_url: string }> };
+    var assets = release.assets ?? [];
+    var asset = assets.find(function (a) { return a.name === assetName; });
+
+    if (!asset) {
+      return { success: false, message: "No binary found for " + assetName + " in latest release" };
+    }
+
+    var downloadRes = await fetch(asset.browser_download_url, {
+      signal: AbortSignal.timeout(120000),
+    });
+
+    if (!downloadRes.ok) {
+      return { success: false, message: "Failed to download binary (HTTP " + downloadRes.status + ")" };
+    }
+
+    var binary = new Uint8Array(await downloadRes.arrayBuffer());
+    var execPath = process.execPath;
+    var tmpPath = execPath + ".update";
+
+    writeFileSync(tmpPath, binary);
+    chmodSync(tmpPath, 0o755);
+    renameSync(tmpPath, execPath);
+
+    return { success: true, message: "Updated successfully. Restart the server to apply." };
+  } catch (err) {
+    return { success: false, message: "Update failed: " + (err instanceof Error ? err.message : String(err)) };
+  }
+}
+
+registerHandler("update", function (clientId: string, message: ClientMessage) {
+  if (message.type === "update:check") {
+    var checkMsg = message as { type: "update:check"; force?: boolean };
+    void checkForUpdate(checkMsg.force ?? false).then(function (info) {
+      sendTo(clientId, {
+        type: "update:status",
+        currentVersion: info.currentVersion,
+        latestVersion: info.latestVersion,
+        updateAvailable: info.updateAvailable,
+        releaseUrl: info.releaseUrl,
+        installMode: info.installMode,
+      });
+    });
+    return;
+  }
+
+  if (message.type === "update:apply") {
+    if (IS_COMPILED) {
+      void downloadBinaryUpdate().then(function (result) {
+        sendTo(clientId, { type: "update:apply_result", success: result.success, message: result.message });
+        if (result.success) {
+          void checkForUpdate(true).then(function (info) {
+            broadcast({
+              type: "update:status",
+              currentVersion: info.currentVersion,
+              latestVersion: info.latestVersion,
+              updateAvailable: info.updateAvailable,
+              releaseUrl: info.releaseUrl,
+              installMode: info.installMode,
+            });
+          });
+        }
+      });
+    } else {
+      var pkgName = getPackageName();
+      try {
+        var proc = Bun.spawn(["bun", "install", "-g", pkgName + "@latest"], {
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+
+        var timeout = setTimeout(function () {
+          proc.kill();
+        }, 120000);
+
+        void proc.exited.then(function (code) {
+          clearTimeout(timeout);
+          if (code === 0) {
+            sendTo(clientId, { type: "update:apply_result", success: true, message: "Updated successfully. Restart the server to apply." });
+            void checkForUpdate(true).then(function (info) {
+              broadcast({
+                type: "update:status",
+                currentVersion: info.currentVersion,
+                latestVersion: info.latestVersion,
+                updateAvailable: info.updateAvailable,
+                releaseUrl: info.releaseUrl,
+                installMode: info.installMode,
+              });
+            });
+          } else {
+            sendTo(clientId, { type: "update:apply_result", success: false, message: "Update failed (exit code " + code + ")" });
+          }
+        });
+      } catch (err) {
+        sendTo(clientId, { type: "update:apply_result", success: false, message: "Failed to start update: " + String(err) });
+      }
+    }
+    return;
+  }
+});

package/server/src/index.ts

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { DAEMON_PID_FILE } from "@lattice/shared";
 import { getLatticeHome, loadConfig } from "./config";
+import { IS_COMPILED } from "./runtime";
 
 var args = process.argv.slice(2);
 var command = "start";
@@ -74,9 +75,12 @@ switch (command) {
   case "status":
     runStatus();
     break;
+  case "update":
+    await runUpdate();
+    break;
   default:
     console.log("[lattice] Unknown command: " + command);
-    console.log("[lattice] Usage: lattice [start|stop|status|daemon]");
+    console.log("[lattice] Usage: lattice [start|stop|status|update|daemon]");
     process.exit(1);
 }
 
@@ -125,10 +129,13 @@ async function runStart(): Promise<void> {
 
   removePid();
 
-  var scriptPath = import.meta.path;
   var logPath = join(getLatticeHome(), "daemon.log");
 
-  var child = Bun.spawn(["bun", scriptPath, "daemon"], {
+  var spawnArgs = IS_COMPILED
+    ? [process.execPath, "daemon"]
+    : ["bun", import.meta.path, "daemon"];
+
+  var child = Bun.spawn(spawnArgs, {
     detached: true,
     stdio: ["ignore", Bun.file(logPath), Bun.file(logPath)],
   });
@@ -194,6 +201,96 @@ function runStatus(): void {
   console.log("[lattice] URL:    " + url);
 }
 
+async function runUpdate(): Promise<void> {
+  var { checkForUpdate, getPackageName, getGitHubRepo } = await import("./update-checker");
+  console.log("[lattice] Checking for updates...");
+  var info = await checkForUpdate(true);
+
+  if (!info.latestVersion) {
+    console.log("[lattice] Could not check for updates. Try again later.");
+    process.exit(1);
+  }
+
+  if (!info.updateAvailable) {
+    console.log("[lattice] Already on latest version (%s)", info.currentVersion);
+    process.exit(0);
+  }
+
+  console.log("[lattice] Update available: %s -> %s (%s)", info.currentVersion, info.latestVersion, info.installMode);
+  console.log("[lattice] Installing...");
+
+  var code: number;
+
+  if (IS_COMPILED) {
+    var { chmodSync, renameSync, writeFileSync } = await import("node:fs");
+    var repo = getGitHubRepo();
+    var platform = process.platform === "darwin" ? "darwin" : "linux";
+    var arch = process.arch === "arm64" ? "arm64" : "x64";
+    var assetName = "lattice-" + platform + "-" + arch;
+
+    try {
+      var releaseRes = await fetch("https://api.github.com/repos/" + repo + "/releases/latest", {
+        headers: { "Accept": "application/vnd.github.v3+json" },
+      });
+      var release = await releaseRes.json() as { assets?: Array<{ name: string; browser_download_url: string }> };
+      var asset = (release.assets ?? []).find(function (a) { return a.name === assetName; });
+
+      if (!asset) {
+        console.error("[lattice] No binary found for " + assetName);
+        process.exit(1);
+      }
+
+      console.log("[lattice] Downloading " + assetName + "...");
+      var downloadRes = await fetch(asset.browser_download_url);
+      var binary = new Uint8Array(await downloadRes.arrayBuffer());
+      var tmpPath = process.execPath + ".update";
+      writeFileSync(tmpPath, binary);
+      chmodSync(tmpPath, 0o755);
+      renameSync(tmpPath, process.execPath);
+      code = 0;
+    } catch (err) {
+      console.error("[lattice] Download failed:", err instanceof Error ? err.message : String(err));
+      code = 1;
+    }
+  } else {
+    var pkgName = getPackageName();
+    var proc = Bun.spawn(["bun", "install", "-g", pkgName + "@latest"], {
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    code = await proc.exited;
+  }
+
+  if (code === 0) {
+    console.log("[lattice] Updated to %s", info.latestVersion);
+
+    var pid = readPid();
+    if (pid !== null && isDaemonRunning(pid)) {
+      console.log("[lattice] Restarting daemon...");
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {}
+      removePid();
+      await new Promise<void>(function (resolve) { setTimeout(resolve, 1000); });
+
+      var logPath = join(getLatticeHome(), "daemon.log");
+      var restartArgs = IS_COMPILED
+        ? [process.execPath, "daemon"]
+        : ["bun", import.meta.path, "daemon"];
+      var child = Bun.spawn(restartArgs, {
+        detached: true,
+        stdio: ["ignore", Bun.file(logPath), Bun.file(logPath)],
+      });
+      child.unref();
+      writePid(child.pid);
+      console.log("[lattice] Daemon restarted (PID %d)", child.pid);
+    }
+  } else {
+    console.error("[lattice] Update failed (exit code %d)", code);
+    process.exit(1);
+  }
+}
+
 function openBrowser(url: string): void {
   var platform = process.platform;
   try {

package/server/src/project/terminal.ts

@@ -2,6 +2,9 @@ import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import type { ChildProcess } from "node:child_process";
 import { join } from "node:path";
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { IS_COMPILED } from "../runtime";
 
 interface TerminalWorker {
   process: ChildProcess;
@@ -10,21 +13,33 @@ interface TerminalWorker {
 
 var terminals = new Map<string, TerminalWorker>();
 
-// node-pty doesn't work under Bun (child gets SIGHUP immediately).
-// We run it in a Node.js subprocess instead, communicating via JSON over stdio.
-var WORKER_PATH = join(import.meta.dir, "pty-worker.cjs");
+function getWorkerPath(): string {
+  if (!IS_COMPILED) {
+    return join(import.meta.dir, "pty-worker.cjs");
+  }
+  var extractedPath = join(homedir(), ".lattice", "pty-worker.cjs");
+  if (!existsSync(extractedPath)) {
+    var srcPath = join(import.meta.dir, "pty-worker.cjs");
+    if (existsSync(srcPath)) {
+      mkdirSync(join(homedir(), ".lattice"), { recursive: true });
+      writeFileSync(extractedPath, readFileSync(srcPath));
+    }
+  }
+  return extractedPath;
+}
+
+var WORKER_PATH = getWorkerPath();
 
-// node-pty lives in Bun's module cache — resolve the path so Node can find it.
 var NODE_MODULES_PATH = (function () {
-  // Bun can resolve the module — use it to find the actual path
   try {
     var resolved = require.resolve("node-pty");
-    // resolved = .../node_modules/.bun/node-pty@X.Y.Z/node_modules/node-pty/lib/index.js
-    // We need: .../node_modules/.bun/node-pty@X.Y.Z/node_modules
     var parts = resolved.split("/node_modules/");
-    parts.pop(); // remove node-pty/lib/index.js
+    parts.pop();
     return parts.join("/node_modules/") + "/node_modules";
   } catch {
+    if (IS_COMPILED) {
+      return "";
+    }
     return join(import.meta.dir, "..", "..", "..", "node_modules");
   }
 })();

package/server/src/runtime.ts

@@ -0,0 +1,4 @@
+export var IS_COMPILED = typeof Bun !== "undefined"
+  && !process.argv[0].endsWith("/bun")
+  && !process.argv[0].endsWith("\\bun.exe")
+  && !process.argv[0].includes("node_modules");

package/server/src/update-checker.ts

@@ -0,0 +1,146 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { log } from "./logger";
+import { IS_COMPILED } from "./runtime";
+
+var PKG_NAME = "@cryptiklemur/lattice";
+var GITHUB_REPO = "cryptiklemur/lattice";
+var CHECK_INTERVAL_MS = 3600000;
+
+export type InstallMode = "binary" | "npm";
+
+export interface UpdateInfo {
+  currentVersion: string;
+  latestVersion: string | null;
+  updateAvailable: boolean;
+  lastCheckedAt: number;
+  releaseUrl: string | null;
+  installMode: InstallMode;
+}
+
+var cached: UpdateInfo | null = null;
+var checking = false;
+
+function getCurrentVersion(): string {
+  if (process.env.LATTICE_VERSION) return process.env.LATTICE_VERSION;
+  try {
+    var pkg = JSON.parse(readFileSync(join(import.meta.dir, "../../package.json"), "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function compareVersions(a: string, b: string): number {
+  var pa = a.replace(/^v/, "").split(".").map(Number);
+  var pb = b.replace(/^v/, "").split(".").map(Number);
+  for (var i = 0; i < 3; i++) {
+    var va = pa[i] || 0;
+    var vb = pb[i] || 0;
+    if (va !== vb) return va - vb;
+  }
+  return 0;
+}
+
+export function getInstallMode(): InstallMode {
+  return IS_COMPILED ? "binary" : "npm";
+}
+
+async function checkGitHub(currentVersion: string): Promise<UpdateInfo> {
+  var res = await fetch("https://api.github.com/repos/" + GITHUB_REPO + "/releases/latest", {
+    headers: { "Accept": "application/vnd.github.v3+json" },
+    signal: AbortSignal.timeout(10000),
+  });
+
+  if (!res.ok) {
+    log.server("GitHub update check failed: HTTP %d", res.status);
+    return { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: "binary" };
+  }
+
+  var data = await res.json() as { tag_name?: string; html_url?: string };
+  var latestVersion = data.tag_name ? data.tag_name.replace(/^v/, "") : null;
+  var updateAvailable = latestVersion !== null && compareVersions(latestVersion, currentVersion) > 0;
+
+  return {
+    currentVersion,
+    latestVersion,
+    updateAvailable,
+    lastCheckedAt: Date.now(),
+    releaseUrl: updateAvailable ? (data.html_url ?? null) : null,
+    installMode: "binary",
+  };
+}
+
+async function checkNpm(currentVersion: string): Promise<UpdateInfo> {
+  var res = await fetch("https://registry.npmjs.org/" + PKG_NAME + "/latest", {
+    headers: { "Accept": "application/json" },
+    signal: AbortSignal.timeout(10000),
+  });
+
+  if (!res.ok) {
+    log.server("npm update check failed: HTTP %d", res.status);
+    return { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: "npm" };
+  }
+
+  var data = await res.json() as { version?: string };
+  var latestVersion = data.version ?? null;
+  var updateAvailable = latestVersion !== null && compareVersions(latestVersion, currentVersion) > 0;
+
+  return {
+    currentVersion,
+    latestVersion,
+    updateAvailable,
+    lastCheckedAt: Date.now(),
+    releaseUrl: updateAvailable ? "https://github.com/" + GITHUB_REPO + "/releases/tag/v" + latestVersion : null,
+    installMode: "npm",
+  };
+}
+
+export async function checkForUpdate(force: boolean = false): Promise<UpdateInfo> {
+  var currentVersion = getCurrentVersion();
+
+  if (!force && cached && Date.now() - cached.lastCheckedAt < CHECK_INTERVAL_MS) {
+    return cached;
+  }
+
+  if (checking) {
+    return cached ?? { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: 0, releaseUrl: null, installMode: getInstallMode() };
+  }
+
+  checking = true;
+  try {
+    cached = IS_COMPILED
+      ? await checkGitHub(currentVersion)
+      : await checkNpm(currentVersion);
+
+    if (cached.updateAvailable) {
+      log.server("Update available: %s -> %s (%s)", currentVersion, cached.latestVersion, cached.installMode);
+    }
+    return cached;
+  } catch (err) {
+    log.server("Update check error: %s", err instanceof Error ? err.message : String(err));
+    cached = { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: getInstallMode() };
+    return cached;
+  } finally {
+    checking = false;
+  }
+}
+
+export function getCachedUpdateInfo(): UpdateInfo | null {
+  return cached;
+}
+
+export function getPackageName(): string {
+  return PKG_NAME;
+}
+
+export function getGitHubRepo(): string {
+  return GITHUB_REPO;
+}
+
+export function startPeriodicUpdateCheck(): void {
+  void checkForUpdate();
+  setInterval(function () {
+    void checkForUpdate();
+  }, CHECK_INTERVAL_MS);
+}

package/shared/src/messages.ts

@@ -505,6 +505,15 @@ export interface PluginErrorsMessage {
   type: "plugin:errors";
 }
 
+export interface UpdateCheckMessage {
+  type: "update:check";
+  force?: boolean;
+}
+
+export interface UpdateApplyMessage {
+  type: "update:apply";
+}
+
 export type ClientMessage =
   | SessionCreateMessage
   | SessionActivateMessage
@@ -576,7 +585,9 @@ export type ClientMessage =
   | PluginUpdateMessage
   | PluginDetailsMessage
   | PluginDiscoverMessage
-  | PluginErrorsMessage;
+  | PluginErrorsMessage
+  | UpdateCheckMessage
+  | UpdateApplyMessage;
 
 export interface SessionListMessage {
   type: "session:list";
@@ -971,6 +982,21 @@ export interface PluginErrorsResultMessage {
   errors: PluginError[];
 }
 
+export interface UpdateStatusMessage {
+  type: "update:status";
+  currentVersion: string;
+  latestVersion: string | null;
+  updateAvailable: boolean;
+  releaseUrl: string | null;
+  installMode: "binary" | "npm";
+}
+
+export interface UpdateApplyResultMessage {
+  type: "update:apply_result";
+  success: boolean;
+  message?: string;
+}
+
 export type ServerMessage =
   | SessionListMessage
   | SessionCreatedMessage
@@ -1047,7 +1073,9 @@ export type ServerMessage =
   | PluginUpdateResultMessage
   | PluginDetailsResultMessage
   | PluginDiscoverResultMessage
-  | PluginErrorsResultMessage;
+  | PluginErrorsResultMessage
+  | UpdateStatusMessage
+  | UpdateApplyResultMessage;
 
 export interface BudgetStatusMessage {
   type: "budget:status";