@cryptiklemur/lattice 1.47.0 → 2.0.0

package/{server/src → src/server}/project/session.ts

@@ -5,7 +5,8 @@ import {
   renameSession as sdkRenameSession,
 } from "@anthropic-ai/claude-agent-sdk";
 import type { SDKSessionInfo, SessionMessage } from "@anthropic-ai/claude-agent-sdk";
-import { existsSync, unlinkSync, readFileSync } from "node:fs";
+import { existsSync, unlinkSync, readFileSync, statSync } from "node:fs";
+import * as fsPromises from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
@@ -138,8 +139,16 @@ function extractUserText(content: unknown): string {
   return "";
 }
 
+var HIDDEN_TOOLS = new Set([
+  "TaskUpdate", "TaskCreate", "TaskGet", "TaskList", "TaskOutput", "TaskStop",
+  "TodoWrite", "TodoRead",
+  "EnterPlanMode", "ExitPlanMode",
+  "ToolSearch",
+]);
+
 function convertSessionMessages(messages: SessionMessage[]): HistoryMessage[] {
   var result: HistoryMessage[] = [];
+  var hiddenToolIds = new Set<string>();
 
   for (var i = 0; i < messages.length; i++) {
     var msg = messages[i];
@@ -147,11 +156,24 @@ function convertSessionMessages(messages: SessionMessage[]): HistoryMessage[] {
     var apiMsg = msg.message as { role?: string; content?: unknown };
 
     if (msg.type === "user") {
+      if ((msg as Record<string, unknown>).isCompactSummary === true) {
+        var summaryText = typeof apiMsg.content === "string" ? apiMsg.content : "";
+        if (summaryText) {
+          result.push({
+            type: "compact_summary",
+            uuid: msg.uuid,
+            text: summaryText,
+            timestamp: ts,
+          });
+        }
+        continue;
+      }
       if (Array.isArray(apiMsg.content)) {
         var hadToolResult = false;
         for (var j = 0; j < apiMsg.content.length; j++) {
           var block = apiMsg.content[j] as { type?: string; text?: string; tool_use_id?: string; content?: unknown };
           if (block.type === "tool_result" && block.tool_use_id) {
+            if (hiddenToolIds.has(block.tool_use_id)) continue;
             hadToolResult = true;
             var resultContent = "";
             if (typeof block.content === "string") {
@@ -212,13 +234,17 @@ function convertSessionMessages(messages: SessionMessage[]): HistoryMessage[] {
               timestamp: ts,
             });
           } else if (aBlock.type === "tool_use" && aBlock.id && aBlock.name) {
-            result.push({
-              type: "tool_start",
-              toolId: aBlock.id,
-              name: aBlock.name,
-              args: JSON.stringify(aBlock.input ?? {}),
-              timestamp: ts,
-            });
+            if (HIDDEN_TOOLS.has(aBlock.name)) {
+              hiddenToolIds.add(aBlock.id);
+            } else {
+              result.push({
+                type: "tool_start",
+                toolId: aBlock.id,
+                name: aBlock.name,
+                args: JSON.stringify(aBlock.input ?? {}),
+                timestamp: ts,
+              });
+            }
           }
         }
         if (msgUsage && lastAssistantIdx >= 0) {
@@ -294,15 +320,14 @@ export async function getSessionUsage(projectSlug: string, sessionId: string): P
   if (!existsSync(sessionFile)) return null;
 
   try {
-    var { openSync, readSync, fstatSync, closeSync } = require("node:fs") as typeof import("node:fs");
-    var fd = openSync(sessionFile, "r");
-    var stat = fstatSync(fd);
-    var tailSize = Math.min(stat.size, 512 * 1024);
-    var buf = Buffer.alloc(tailSize);
-    readSync(fd, buf, 0, tailSize, stat.size - tailSize);
-    closeSync(fd);
-
-    var text = buf.toString("utf-8");
+    var fhUsage = await fsPromises.open(sessionFile, "r");
+    var statUsage = await fhUsage.stat();
+    var tailSize = Math.min(statUsage.size, 512 * 1024);
+    var bufUsage = Buffer.alloc(tailSize);
+    await fhUsage.read(bufUsage, 0, tailSize, statUsage.size - tailSize);
+    await fhUsage.close();
+
+    var text = bufUsage.toString("utf-8");
     var lines = text.split("\n");
 
     for (var i = lines.length - 1; i >= 0; i--) {
@@ -453,6 +478,12 @@ export function invalidateSessionCache(projectSlug: string): void {
   sessionListCache.delete(projectSlug);
 }
 
+export function invalidateHistoryCache(sessionId: string): void {
+  historyCache.delete(sessionId);
+  var idx = historyCacheOrder.indexOf(sessionId);
+  if (idx >= 0) historyCacheOrder.splice(idx, 1);
+}
+
 export async function getSessionTitle(projectSlug: string, sessionId: string): Promise<string> {
   var projectPath = getProjectPath(projectSlug);
   var options = projectPath ? { dir: projectPath } : undefined;
@@ -489,8 +520,8 @@ export function appendToHistoryCache(sessionId: string, message: HistoryMessage)
   touchCache(sessionId);
 }
 
-var INITIAL_MESSAGE_COUNT = 100;
-var TAIL_READ_BYTES = 2 * 1024 * 1024;
+var INITIAL_MESSAGE_COUNT = 300;
+var TAIL_READ_BYTES = 512 * 1024;
 
 function getSessionFilePath(projectSlug: string, sessionId: string): string | null {
   var projectPath = getProjectPath(projectSlug);
@@ -500,21 +531,34 @@ function getSessionFilePath(projectSlug: string, sessionId: string): string | nu
   return existsSync(filePath) ? filePath : null;
 }
 
-function readTailLines(filePath: string, maxBytes: number): { lines: string[]; isPartial: boolean; fileSize: number } {
-  var { openSync, readSync, fstatSync, closeSync } = require("node:fs") as typeof import("node:fs");
-  var fd = openSync(filePath, "r");
-  var stat = fstatSync(fd);
-  var readStart = Math.max(0, stat.size - maxBytes);
-  var buf = Buffer.alloc(stat.size - readStart);
-  readSync(fd, buf, 0, buf.length, readStart);
-  closeSync(fd);
-  var text = buf.toString("utf-8");
-  if (readStart > 0) {
-    var firstNewline = text.indexOf("\n");
-    if (firstNewline >= 0) text = text.slice(firstNewline + 1);
+export function getSessionFileSizeBytes(projectSlug: string, sessionId: string): number | null {
+  var filePath = getSessionFilePath(projectSlug, sessionId);
+  if (!filePath) return null;
+  try {
+    return statSync(filePath).size;
+  } catch {
+    return null;
+  }
+}
+
+async function readTailLines(filePath: string, maxBytes: number): Promise<{ lines: string[]; isPartial: boolean; fileSize: number }> {
+  var fh = await fsPromises.open(filePath, "r");
+  try {
+    var stat = await fh.stat();
+    var readStart = Math.max(0, stat.size - maxBytes);
+    var length = stat.size - readStart;
+    var buf = Buffer.alloc(length);
+    await fh.read(buf, 0, length, readStart);
+    var text = buf.toString("utf-8");
+    if (readStart > 0) {
+      var firstNewline = text.indexOf("\n");
+      if (firstNewline >= 0) text = text.slice(firstNewline + 1);
+    }
+    var lines = text.split("\n").filter(function (l) { return l.length > 0; });
+    return { lines, isPartial: readStart > 0, fileSize: stat.size };
+  } finally {
+    await fh.close();
   }
-  var lines = text.split("\n").filter(function (l) { return l.length > 0; });
-  return { lines, isPartial: readStart > 0, fileSize: stat.size };
 }
 
 function parseJsonlLines(lines: string[]): SessionMessage[] {
@@ -545,14 +589,14 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
 
     var filePath = getSessionFilePath(projectSlug, sessionId);
     if (filePath) {
-      var tailData = readTailLines(filePath, TAIL_READ_BYTES);
+      var tailData = await readTailLines(filePath, TAIL_READ_BYTES);
       var tailRaw = parseJsonlLines(tailData.lines);
       var tailMessages = convertSessionMessages(tailRaw);
       var hasMore = tailData.isPartial;
 
       log.session("loadSessionHistory %s: %dms (tail read, %d msgs, partial=%s)", sessionId.slice(0, 8), Date.now() - t0, tailMessages.length, hasMore);
 
-      if (!hasMore) {
+      if (!hasMore && tailMessages.length > 0) {
         historyCache.set(sessionId, { messages: tailMessages, title: null });
         touchCache(sessionId);
         evictOldest();
@@ -569,9 +613,11 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
     var options = projectPath ? { dir: projectPath } : undefined;
     var rawMessages = await getSessionMessages(sessionId, options);
     var allMessages = convertSessionMessages(rawMessages);
-    historyCache.set(sessionId, { messages: allMessages, title: null });
-    touchCache(sessionId);
-    evictOldest();
+    if (allMessages.length > 0) {
+      historyCache.set(sessionId, { messages: allMessages, title: null });
+      touchCache(sessionId);
+      evictOldest();
+    }
     log.session("loadSessionHistory %s: %dms (full SDK, %d msgs)", sessionId.slice(0, 8), Date.now() - t0, allMessages.length);
     var tailSlice = allMessages.length > INITIAL_MESSAGE_COUNT
       ? allMessages.slice(allMessages.length - INITIAL_MESSAGE_COUNT)

package/{server/src → src/server}/project/terminal.ts

@@ -1,10 +1,11 @@
 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";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+
+var __dirname_local = dirname(fileURLToPath(import.meta.url));
 
 interface TerminalWorker {
   process: ChildProcess;
@@ -13,22 +14,7 @@ interface TerminalWorker {
 
 var terminals = new Map<string, TerminalWorker>();
 
-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();
+var WORKER_PATH = join(__dirname_local, "pty-worker.cjs");
 
 var NODE_MODULES_PATH = (function () {
   try {
@@ -37,10 +23,7 @@ var NODE_MODULES_PATH = (function () {
     parts.pop();
     return parts.join("/node_modules/") + "/node_modules";
   } catch {
-    if (IS_COMPILED) {
-      return "";
-    }
-    return join(import.meta.dir, "..", "..", "..", "node_modules");
+    return join(__dirname_local, "..", "..", "..", "node_modules");
   }
 })();
 

package/{server/src → src/server}/project/warmup.ts

@@ -5,6 +5,9 @@ import { log } from "../logger";
 import { loadConfig } from "../config";
 import { listSessions, loadSessionHistory } from "./session";
 import { execSync } from "node:child_process";
+import { existsSync, unlinkSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
 
 var claudeExePath: string | null = null;
 
@@ -35,6 +38,18 @@ var warmupSlashCommands: string[] = [];
 var warmupAccountInfo: AccountInfo | null = null;
 var warmupComplete = false;
 
+interface WarmupRateLimitEntry {
+  status: string;
+  utilization?: number;
+  resetsAt?: number;
+  rateLimitType?: string;
+  overageStatus?: string;
+  overageResetsAt?: number;
+  isUsingOverage?: boolean;
+}
+
+var warmupRateLimits: Map<string, WarmupRateLimitEntry> = new Map();
+
 function ensureKnownModels(sdkModels: ModelEntry[]): ModelEntry[] {
   var seen = new Set<string>();
   for (var i = 0; i < sdkModels.length; i++) {
@@ -49,11 +64,31 @@ function ensureKnownModels(sdkModels: ModelEntry[]): ModelEntry[] {
   return result;
 }
 
+function deleteWarmupSession(cwd: string, sessionId: string | null): void {
+  if (!sessionId) return;
+  try {
+    var hash = cwd.replace(/\//g, "-");
+    var projectDir = join(homedir(), ".claude", "projects", hash);
+    var jsonlPath = join(projectDir, sessionId + ".jsonl");
+    var dirPath = join(projectDir, sessionId);
+    if (existsSync(jsonlPath)) {
+      unlinkSync(jsonlPath);
+      log.server("Deleted warmup session file: %s", sessionId);
+    }
+    if (existsSync(dirPath)) {
+      rmSync(dirPath, { recursive: true, force: true });
+    }
+  } catch (err) {
+    log.server("Failed to delete warmup session: %O", err);
+  }
+}
+
 export async function runWarmup(cwd: string): Promise<void> {
   log.server("SDK warmup starting (cwd: %s)...", cwd);
   try {
     var ac = new AbortController();
     var ended = false;
+    var WARMUP_SESSION_ID = "lattice-warmup";
 
     var mq = {
       [Symbol.asyncIterator]: function () {
@@ -66,7 +101,7 @@ export async function runWarmup(cwd: string): Promise<void> {
                 type: "user" as const,
                 message: { role: "user" as const, content: [{ type: "text" as const, text: "hi" }] },
                 parent_tool_use_id: null,
-                session_id: "warmup",
+                session_id: WARMUP_SESSION_ID,
               },
               done: false,
             });
@@ -79,6 +114,7 @@ export async function runWarmup(cwd: string): Promise<void> {
       prompt: mq as any,
       options: {
         cwd,
+        sessionId: WARMUP_SESSION_ID,
         settingSources: ["user", "project", "local"],
         abortController: ac,
         permissionMode: "plan",
@@ -89,12 +125,10 @@ export async function runWarmup(cwd: string): Promise<void> {
       },
     });
 
-    var gotInit = false;
     for await (var msg of stream) {
       if (msg.type === "system") {
         var sysMsg = msg as any;
         if (sysMsg.subtype === "init") {
-          gotInit = true;
           if (sysMsg.slash_commands) {
             warmupSlashCommands = sysMsg.slash_commands;
           }
@@ -109,12 +143,25 @@ export async function runWarmup(cwd: string): Promise<void> {
           try {
             warmupAccountInfo = await stream.accountInfo();
           } catch {}
+
+          ac.abort();
+          break;
         }
       }
 
       if (msg.type === "rate_limit_event") {
         var rlMsg = msg as { type: string; rate_limit_info: { status: string; utilization?: number; resetsAt?: number; rateLimitType?: string; overageStatus?: string; overageResetsAt?: number; isUsingOverage?: boolean } };
         var rli = rlMsg.rate_limit_info;
+        var cacheKey = rli.rateLimitType || "default";
+        warmupRateLimits.set(cacheKey, {
+          status: rli.status,
+          utilization: rli.utilization,
+          resetsAt: rli.resetsAt,
+          rateLimitType: rli.rateLimitType,
+          overageStatus: rli.overageStatus,
+          overageResetsAt: rli.overageResetsAt,
+          isUsingOverage: rli.isUsingOverage,
+        });
         broadcast({
           type: "chat:rate_limit",
           status: rli.status,
@@ -126,14 +173,10 @@ export async function runWarmup(cwd: string): Promise<void> {
           isUsingOverage: rli.isUsingOverage,
         } as any);
       }
-
-      if (msg.type === "result" && gotInit) {
-        ac.abort();
-        break;
-      }
     }
 
     warmupComplete = true;
+    deleteWarmupSession(cwd, WARMUP_SESSION_ID);
     log.server("SDK warmup complete: %d models, %d commands, auth=%s",
       warmupModels.length, warmupSlashCommands.length,
       warmupAccountInfo?.apiKeySource || "unknown");
@@ -194,10 +237,11 @@ async function warmupProjectData(): Promise<void> {
         sessions: result.sessions,
         totalCount: result.totalCount,
       } as any);
-      if (result.sessions.length > 0) {
+      var preWarmCount = Math.min(5, result.sessions.length);
+      for (var k = 0; k < preWarmCount; k++) {
         recentSessionIds.push({
           projectSlug: projects[i].slug,
-          sessionId: result.sessions[0].id,
+          sessionId: result.sessions[k].id,
         });
       }
     } catch {}
@@ -227,6 +271,15 @@ export function getWarmupAccountInfo(): AccountInfo | null {
   return warmupAccountInfo;
 }
 
+export function getWarmupRateLimits(): WarmupRateLimitEntry[] {
+  return Array.from(warmupRateLimits.values());
+}
+
+export function cacheRateLimitEntry(entry: WarmupRateLimitEntry): void {
+  var key = entry.rateLimitType || "default";
+  warmupRateLimits.set(key, entry);
+}
+
 export function isWarmupComplete(): boolean {
   return warmupComplete;
 }

package/src/server/push.ts

@@ -0,0 +1,121 @@
+import webpush from "web-push";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getLatticeHome } from "./config";
+import { log } from "./logger";
+
+interface VapidKeys {
+  publicKey: string;
+  privateKey: string;
+}
+
+interface PushSubscription {
+  endpoint: string;
+  keys: {
+    p256dh: string;
+    auth: string;
+  };
+}
+
+var vapidKeys: VapidKeys | null = null;
+var subscriptions = new Map<string, PushSubscription>();
+
+function getVapidPath(): string {
+  return join(getLatticeHome(), "vapid.json");
+}
+
+function getSubscriptionsPath(): string {
+  return join(getLatticeHome(), "push-subs.json");
+}
+
+function ensureVapidKeys(): VapidKeys {
+  if (vapidKeys) return vapidKeys;
+
+  var vapidPath = getVapidPath();
+  if (existsSync(vapidPath)) {
+    try {
+      vapidKeys = JSON.parse(readFileSync(vapidPath, "utf-8"));
+      if (vapidKeys) return vapidKeys;
+    } catch {}
+  }
+
+  var generated = webpush.generateVAPIDKeys();
+  vapidKeys = {
+    publicKey: generated.publicKey,
+    privateKey: generated.privateKey,
+  };
+
+  var dir = getLatticeHome();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(vapidPath, JSON.stringify(vapidKeys, null, 2), "utf-8");
+  log.server("Generated VAPID keys for push notifications");
+  return vapidKeys;
+}
+
+function loadSubscriptions(): void {
+  var subsPath = getSubscriptionsPath();
+  if (!existsSync(subsPath)) return;
+  try {
+    var data = JSON.parse(readFileSync(subsPath, "utf-8")) as PushSubscription[];
+    for (var i = 0; i < data.length; i++) {
+      subscriptions.set(data[i].endpoint, data[i]);
+    }
+  } catch {}
+}
+
+function saveSubscriptions(): void {
+  var arr: PushSubscription[] = [];
+  subscriptions.forEach(function (sub) {
+    arr.push(sub);
+  });
+  writeFileSync(getSubscriptionsPath(), JSON.stringify(arr), "utf-8");
+}
+
+export function initPush(): void {
+  var keys = ensureVapidKeys();
+  webpush.setVapidDetails(
+    "mailto:lattice@localhost",
+    keys.publicKey,
+    keys.privateKey,
+  );
+  loadSubscriptions();
+  log.server("Push notifications ready (%d subscription(s))", subscriptions.size);
+}
+
+export function getVapidPublicKey(): string {
+  return ensureVapidKeys().publicKey;
+}
+
+export function addPushSubscription(sub: PushSubscription): void {
+  subscriptions.set(sub.endpoint, sub);
+  saveSubscriptions();
+}
+
+export function removePushSubscription(endpoint: string): void {
+  subscriptions.delete(endpoint);
+  saveSubscriptions();
+}
+
+export interface PushPayload {
+  type: "done" | "permission_request" | "elicitation" | "error";
+  title: string;
+  body: string;
+  sessionId?: string;
+  projectSlug?: string;
+}
+
+export function sendPush(payload: PushPayload): void {
+  if (subscriptions.size === 0) return;
+
+  var json = JSON.stringify(payload);
+  subscriptions.forEach(function (sub, endpoint) {
+    webpush.sendNotification(sub, json).catch(function (err: { statusCode?: number }) {
+      if (err.statusCode === 410 || err.statusCode === 404 || err.statusCode === 403) {
+        subscriptions.delete(endpoint);
+        saveSubscriptions();
+      }
+    });
+  });
+}

package/src/server/runtime.ts

@@ -0,0 +1 @@
+export var IS_NPM = true;

package/src/server/tui.ts

@@ -0,0 +1,103 @@
+import * as p from "@clack/prompts";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getLatticeHome, loadConfig, saveConfig } from "./config";
+import type { LatticeConfig } from "@lattice/shared";
+import { DEFAULT_PORT } from "@lattice/shared";
+
+var BANNER = `
+  \x1b[36m██╗\x1b[0m      \x1b[36m█████╗\x1b[0m \x1b[36m████████╗████████╗██╗\x1b[0m \x1b[36m██████╗\x1b[0m \x1b[36m███████╗\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m██╔══██╗\x1b[0m\x1b[2m╚══\x1b[0m\x1b[36m██\x1b[0m\x1b[2m╔══╝╚══\x1b[0m\x1b[36m██\x1b[0m\x1b[2m╔══╝\x1b[0m\x1b[36m██║\x1b[0m\x1b[36m██╔════╝\x1b[0m\x1b[36m██╔════╝\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m███████║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║██║\x1b[0m     \x1b[36m█████╗\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m██╔══██║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║██║\x1b[0m     \x1b[36m██╔══╝\x1b[0m
+  \x1b[36m███████╗██║  ██║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║\x1b[0m\x1b[2m╚\x1b[0m\x1b[36m██████╗███████╗\x1b[0m
+  \x1b[2m╚══════╝╚═╝  ╚═╝   ╚═╝      ╚═╝   ╚═╝ ╚═════╝╚══════╝\x1b[0m
+`;
+
+export function printBanner(): void {
+  console.log(BANNER);
+}
+
+export function printStatus(config: LatticeConfig, version: string, projectCount: number, sessionCount: number): void {
+  var protocol = config.tls ? "https" : "http";
+  var url = protocol + "://localhost:" + config.port;
+
+  console.log("");
+  p.note(
+    "lattice v" + version + " — " + url + "\n" +
+    projectCount + " project" + (projectCount !== 1 ? "s" : "") +
+    " · " + sessionCount + " session" + (sessionCount !== 1 ? "s" : "") + "\n" +
+    "Press Ctrl+C to stop",
+    "Running"
+  );
+  console.log("");
+}
+
+export async function printQrCode(url: string): Promise<void> {
+  try {
+    var qrcode = await import("qrcode");
+    var qr = await (qrcode as any).toString(url, {
+      type: "terminal",
+      small: true,
+    });
+    console.log(qr);
+    console.log("  \x1b[2m" + url + "\x1b[0m");
+    console.log("");
+  } catch {
+    console.log("  " + url);
+    console.log("");
+  }
+}
+
+export async function runOnboarding(): Promise<{ port: number; passphrase: string | null }> {
+  var configPath = join(getLatticeHome(), "config.json");
+  var isFirstRun = !existsSync(configPath);
+
+  if (!isFirstRun) {
+    var config = loadConfig();
+    return { port: config.port, passphrase: null };
+  }
+
+  printBanner();
+
+  p.intro("Welcome to Lattice");
+
+  p.note(
+    "Anyone with the URL gets full Claude Code access to this machine.\n" +
+    "Use a private network (Tailscale, VPN) or set a passphrase.",
+    "Security"
+  );
+
+  var portResult = await p.text({
+    message: "Port",
+    placeholder: String(DEFAULT_PORT),
+    defaultValue: String(DEFAULT_PORT),
+    validate: function (val: string | undefined) {
+      var n = parseInt(val || "", 10);
+      if (isNaN(n) || n < 1 || n > 65535) return "Enter a valid port (1-65535)";
+      return undefined;
+    },
+  });
+  if (p.isCancel(portResult)) {
+    p.cancel("Setup cancelled");
+    process.exit(0);
+  }
+  var port = parseInt(portResult as string, 10);
+
+  var passphraseResult = await p.password({
+    message: "Passphrase (optional, press Enter to skip)",
+  });
+  if (p.isCancel(passphraseResult)) {
+    p.cancel("Setup cancelled");
+    process.exit(0);
+  }
+  var passphrase = (passphraseResult as string) || null;
+
+  p.outro("Setup complete");
+
+  var config = loadConfig();
+  config.port = port;
+  saveConfig(config);
+
+  return { port, passphrase };
+}