@wrongstack/webui 0.1.7

package/dist/server/index.js

@@ -0,0 +1,1171 @@
+// src/server/index.ts
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+import { WebSocketServer, WebSocket } from "ws";
+import {
+  Agent,
+  AutoCompactionMiddleware,
+  Container,
+  Context,
+  DefaultConfigLoader,
+  DefaultConfigStore,
+  DefaultErrorHandler,
+  DefaultLogger,
+  DefaultMemoryStore,
+  DefaultModelsRegistry,
+  DefaultPathResolver,
+  DefaultPermissionPolicy,
+  DefaultRetryPolicy,
+  DefaultSecretScrubber,
+  DefaultSecretVault,
+  DefaultSessionStore,
+  DefaultSkillLoader,
+  DefaultModeStore,
+  DefaultSystemPromptBuilder,
+  DefaultTokenCounter,
+  EventBus,
+  HybridCompactor,
+  ProviderRegistry,
+  ToolRegistry,
+  TOKENS,
+  createDefaultPipelines,
+  atomicWrite,
+  migratePlaintextSecrets,
+  resolveWstackPaths
+} from "@wrongstack/core";
+import {
+  buildProviderFactoriesFromRegistry,
+  makeProviderFromConfig
+} from "@wrongstack/providers";
+import { builtinTools } from "@wrongstack/tools/builtin";
+import { rememberTool, forgetTool } from "@wrongstack/tools";
+async function bootConfig() {
+  const cwd = process.cwd();
+  const pathResolver = new DefaultPathResolver(cwd);
+  const projectRoot = pathResolver.projectRoot;
+  const userHome = os.homedir();
+  const wpaths = resolveWstackPaths({ projectRoot, userHome });
+  await fs.mkdir(wpaths.globalRoot, { recursive: true });
+  await fs.mkdir(wpaths.projectDir, { recursive: true });
+  await fs.mkdir(wpaths.projectSessions, { recursive: true });
+  const vault = new DefaultSecretVault({ keyFile: wpaths.secretsKey });
+  for (const file of [wpaths.globalConfig, wpaths.projectLocalConfig]) {
+    try {
+      const { migrated } = await migratePlaintextSecrets(file, vault);
+      if (migrated > 0) {
+        process.stderr.write(`[WebUI] Encrypted ${migrated} plaintext secret(s) in ${file}
+`);
+      }
+    } catch {
+    }
+  }
+  const configLoader = new DefaultConfigLoader({ paths: wpaths, vault });
+  const config = await configLoader.load({ cliFlags: {} });
+  const logger = new DefaultLogger({
+    level: config.log?.level ?? "info",
+    file: wpaths.logFile
+  });
+  return {
+    config,
+    vault,
+    globalConfigPath: wpaths.globalConfig,
+    projectRoot,
+    wpaths,
+    logger
+  };
+}
+function patchConfig(config, updates) {
+  return Object.freeze({ ...config, ...updates });
+}
+async function startWebUI(opts = {}) {
+  const wsPort = opts.wsPort ?? 3457;
+  const wsHost = opts.wsHost ?? "127.0.0.1";
+  console.log("[WebUI] Starting backend services...");
+  const boot = await bootConfig();
+  const { config: baseConfig, vault, globalConfigPath, projectRoot, wpaths, logger } = boot;
+  let config = baseConfig;
+  console.log("[WebUI] Config loaded:", config.provider, "/", config.model);
+  const modelsRegistry = new DefaultModelsRegistry({
+    cacheFile: wpaths.modelsCache,
+    ttlSeconds: 24 * 3600
+  });
+  const container = new Container();
+  const configStore = new DefaultConfigStore(config);
+  container.bind(TOKENS.ConfigStore, () => configStore);
+  container.bind(TOKENS.Logger, () => logger);
+  container.bind(TOKENS.SecretScrubber, () => new DefaultSecretScrubber());
+  container.bind(TOKENS.RetryPolicy, () => new DefaultRetryPolicy());
+  container.bind(TOKENS.ErrorHandler, () => new DefaultErrorHandler());
+  container.bind(TOKENS.ModelsRegistry, () => modelsRegistry);
+  container.bind(TOKENS.PermissionPolicy, () => new DefaultPermissionPolicy({
+    trustFile: wpaths.projectTrust,
+    yolo: false,
+    promptDelegate: void 0
+  }));
+  const providerRegistry = new ProviderRegistry();
+  try {
+    const factories = await buildProviderFactoriesFromRegistry({
+      registry: modelsRegistry,
+      log: logger
+    });
+    for (const f of factories) providerRegistry.register(f);
+    console.log("[WebUI] Provider registry loaded:", providerRegistry.list().length, "providers");
+  } catch (err) {
+    console.warn("[WebUI] Failed to load provider registry:", err);
+  }
+  const toolRegistry = new ToolRegistry();
+  for (const t of builtinTools) toolRegistry.register(t);
+  const memoryStore = new DefaultMemoryStore({ paths: wpaths });
+  if (config.features.memory) {
+    toolRegistry.register(rememberTool(memoryStore));
+    toolRegistry.register(forgetTool(memoryStore));
+  }
+  console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
+  const events = new EventBus();
+  events.setLogger(logger);
+  const sessionStore = new DefaultSessionStore({ dir: wpaths.projectSessions });
+  let session = await sessionStore.create({
+    id: "",
+    title: "",
+    model: config.model,
+    provider: config.provider
+  });
+  let sessionStartedAt = Date.now();
+  console.log("[WebUI] Session created:", session.id);
+  const tokenCounter = new DefaultTokenCounter({
+    registry: modelsRegistry,
+    providerId: config.provider
+  });
+  const modeStore = new DefaultModeStore({ directory: wpaths.configDir });
+  const activeMode = await modeStore.getActiveMode();
+  let modeId = activeMode?.id ?? "default";
+  const modePrompt = activeMode?.prompt ?? "";
+  const resolvedModel = await modelsRegistry.getModel(config.provider, config.model);
+  const modelCapabilities = resolvedModel?.capabilities ? {
+    maxContextTokens: resolvedModel.capabilities.maxContext,
+    supportsTools: resolvedModel.capabilities.tools,
+    supportsVision: resolvedModel.capabilities.vision,
+    supportsReasoning: resolvedModel.capabilities.reasoning
+  } : void 0;
+  const skillLoader = config.features.skills ? new DefaultSkillLoader({ paths: wpaths }) : void 0;
+  const systemPromptBuilder = new DefaultSystemPromptBuilder({
+    memoryStore,
+    skillLoader,
+    modeStore,
+    modeId,
+    modePrompt,
+    modelCapabilities
+  });
+  const systemPrompt = await systemPromptBuilder.build({
+    cwd: projectRoot,
+    projectRoot,
+    tools: toolRegistry.list(),
+    provider: config.provider,
+    model: config.model
+  });
+  const providerConfig = config.providers?.[config.provider] ?? {
+    type: config.provider,
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  };
+  let provider;
+  try {
+    const cfgWithType = { ...providerConfig, type: config.provider };
+    if (config.features.modelsRegistry && providerRegistry.has(config.provider)) {
+      provider = providerRegistry.create(cfgWithType);
+    } else {
+      provider = makeProviderFromConfig(config.provider, cfgWithType);
+    }
+  } catch (err) {
+    console.error("[WebUI] Failed to create provider:", err);
+    throw err;
+  }
+  const context = new Context({
+    systemPrompt,
+    provider,
+    session,
+    signal: new AbortController().signal,
+    tokenCounter,
+    cwd: projectRoot,
+    projectRoot,
+    model: config.model
+  });
+  const pipelines = createDefaultPipelines();
+  const compactor = new HybridCompactor({
+    preserveK: config.context?.preserveK ?? 20,
+    eliseThreshold: config.context?.eliseThreshold ?? 0.7
+  });
+  if (config.context?.autoCompact !== false) {
+    const autoCompactor = new AutoCompactionMiddleware(
+      compactor,
+      2e5,
+      (ctx) => {
+        let total = 0;
+        for (const m of ctx.messages) {
+          if (typeof m.content === "string") total += Math.ceil(m.content.length / 4);
+        }
+        return total;
+      },
+      { warn: 0.7, soft: 0.85, hard: 0.95 },
+      { events }
+    );
+    pipelines.contextWindow.use({ name: "AutoCompaction", handler: autoCompactor.handler() });
+  }
+  const agent = new Agent({
+    container,
+    tools: toolRegistry,
+    providers: providerRegistry,
+    events,
+    pipelines,
+    context,
+    maxIterations: config.tools?.maxIterations ?? 100,
+    iterationTimeoutMs: config.tools?.iterationTimeoutMs ?? 12e4,
+    executionStrategy: config.tools?.defaultExecutionStrategy ?? "sequential",
+    perIterationOutputCapBytes: config.tools?.perIterationOutputCapBytes ?? 5e4,
+    confirmAwaiter: void 0
+  });
+  console.log("[WebUI] Agent initialized");
+  async function sessionStartPayload() {
+    let maxContext = 0;
+    let inputCost = 0;
+    let outputCost = 0;
+    let cacheReadCost = 0;
+    try {
+      const m = await modelsRegistry.getModel(config.provider, config.model);
+      maxContext = m?.capabilities?.maxContext ?? 0;
+      const cost = m?.cost;
+      inputCost = cost?.input ?? 0;
+      outputCost = cost?.output ?? 0;
+      cacheReadCost = cost?.cache_read ?? 0;
+    } catch {
+    }
+    return {
+      sessionId: session.id,
+      model: config.model,
+      provider: config.provider,
+      maxContext,
+      inputCost,
+      outputCost,
+      cacheReadCost,
+      projectName: path.basename(projectRoot) || projectRoot,
+      cwd: projectRoot,
+      mode: modeId
+    };
+  }
+  const wssPrimary = new WebSocketServer({ port: wsPort, host: wsHost });
+  const wssSecondary = wsHost === "127.0.0.1" ? new WebSocketServer({ port: wsPort, host: "::1" }) : null;
+  const clients = /* @__PURE__ */ new Map();
+  let abortController = null;
+  console.log(
+    `[WebUI] WebSocket server running on ws://${wsHost}:${wsPort}` + (wssSecondary ? ` (and ws://[::1]:${wsPort})` : "")
+  );
+  function setupEvents() {
+    events.on("iteration.started", (e) => {
+      broadcast({
+        type: "iteration.started",
+        payload: { index: e.index, maxIterations: config.tools?.maxIterations ?? 100 }
+      });
+    });
+    events.on("provider.text_delta", (e) => {
+      broadcast({ type: "provider.text_delta", payload: { text: e.text, messageId: "current" } });
+    });
+    events.on("tool.started", (e) => {
+      broadcast({
+        type: "tool.started",
+        payload: { id: e.id, name: e.name, input: e.input, messageId: `tool_${e.id}` }
+      });
+    });
+    events.on("tool.progress", (e) => {
+      broadcast({
+        type: "tool.progress",
+        payload: {
+          id: e.id,
+          name: e.name,
+          eventType: e.event.type,
+          text: e.event.text
+        }
+      });
+    });
+    events.on("tool.executed", (e) => {
+      broadcast({
+        type: "tool.executed",
+        payload: {
+          // Forward the tool_use id so frontend can correlate with the
+          // matching tool.started bubble — without this, parallel tool calls
+          // all stay stuck on "Running…" because the frontend can't tell
+          // which bubble this result belongs to.
+          id: e.id,
+          name: e.name,
+          durationMs: e.durationMs,
+          ok: e.ok,
+          input: e.input,
+          output: e.output
+        }
+      });
+      broadcast({
+        type: "todos.updated",
+        payload: { todos: [...context.todos] }
+      });
+    });
+    events.on("provider.response", (e) => {
+      broadcast({
+        type: "provider.response",
+        payload: {
+          usage: e.usage,
+          stopReason: e.stopReason,
+          messageId: "current"
+        }
+      });
+    });
+    events.on("error", (e) => {
+      broadcast({
+        type: "error",
+        payload: {
+          phase: e.phase,
+          message: e.err instanceof Error ? e.err.message : String(e.err)
+        }
+      });
+    });
+  }
+  function send(ws, msg) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  function broadcast(msg) {
+    const data = JSON.stringify(msg);
+    for (const [ws] of clients) {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(data);
+      }
+    }
+  }
+  const handleConnection = (ws) => {
+    const client = { ws, sessionId: session.id };
+    clients.set(ws, client);
+    console.log("[WebUI] Client connected, total:", clients.size);
+    void sessionStartPayload().then((payload) => {
+      send(ws, { type: "session.start", payload });
+    });
+    ws.on("message", async (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        await handleMessage(ws, client, msg);
+      } catch (err) {
+        console.error("[WebUI] Failed to parse message", err);
+      }
+    });
+    ws.on("close", () => {
+      clients.delete(ws);
+      console.log("[WebUI] Client disconnected, total:", clients.size);
+    });
+    ws.on("error", (err) => {
+      console.warn("[WebUI] Client socket error:", err.message);
+    });
+  };
+  let eventsArmed = false;
+  const armOnce = (label) => {
+    if (eventsArmed) return;
+    eventsArmed = true;
+    console.log(`[WebUI] Backend ready (${label})`);
+    setupEvents();
+  };
+  wssPrimary.on("listening", () => armOnce(`${wsHost}:${wsPort}`));
+  wssPrimary.on("connection", handleConnection);
+  wssPrimary.on("error", (err) => {
+    console.error(`[WebUI] Primary WS server error (${wsHost}):`, err);
+  });
+  if (wssSecondary) {
+    wssSecondary.on("listening", () => armOnce(`::1:${wsPort}`));
+    wssSecondary.on("connection", handleConnection);
+    wssSecondary.on("error", (err) => {
+      if (err.code === "EAFNOSUPPORT" || err.code === "EADDRNOTAVAIL") {
+        console.warn("[WebUI] IPv6 loopback not available, v4-only:", err.code);
+      } else {
+        console.error("[WebUI] Secondary WS server error (::1):", err);
+      }
+    });
+  }
+  async function handleMessage(ws, client, msg) {
+    switch (msg.type) {
+      case "user_message": {
+        const content = msg.payload.content;
+        abortController?.abort();
+        abortController = new AbortController();
+        try {
+          const result = await agent.run(content, { signal: abortController.signal });
+          send(ws, {
+            type: "run.result",
+            payload: {
+              status: result.status,
+              iterations: result.iterations,
+              finalText: result.finalText,
+              error: result.error ? {
+                code: result.error.code,
+                message: result.error.message,
+                recoverable: result.error.recoverable
+              } : void 0
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "error",
+            payload: {
+              phase: "agent.run",
+              message: err instanceof Error ? err.message : String(err)
+            }
+          });
+        } finally {
+          abortController = null;
+        }
+        break;
+      }
+      case "abort":
+        abortController?.abort();
+        broadcast({ type: "error", payload: { phase: "abort", message: "User aborted" } });
+        break;
+      case "ping":
+        send(ws, { type: "pong", payload: {} });
+        break;
+      case "session.new": {
+        session = await sessionStore.create({
+          id: "",
+          title: "",
+          model: config.model,
+          provider: config.provider
+        });
+        context.session = session;
+        context.state.replaceMessages([]);
+        context.state.replaceTodos([]);
+        context.readFiles.clear();
+        context.fileMtimes.clear();
+        tokenCounter.reset();
+        sessionStartedAt = Date.now();
+        broadcast({ type: "session.start", payload: await sessionStartPayload() });
+        break;
+      }
+      case "context.clear": {
+        context.state.replaceMessages([]);
+        context.state.replaceTodos([]);
+        context.readFiles.clear();
+        context.fileMtimes.clear();
+        tokenCounter.reset();
+        sendResult(ws, true, "Context cleared");
+        broadcast({
+          type: "session.start",
+          payload: { ...await sessionStartPayload(), reset: true }
+        });
+        break;
+      }
+      case "context.debug": {
+        const estimate = (s) => Math.ceil(s.length / 4);
+        const stringifyContent = (c) => {
+          if (typeof c === "string") return c;
+          try {
+            return JSON.stringify(c);
+          } catch {
+            return String(c);
+          }
+        };
+        const sysTokens = context.systemPrompt.reduce(
+          (acc, b) => acc + estimate(b.text ?? ""),
+          0
+        );
+        const tools = toolRegistry.list();
+        const toolBreakdown = tools.map((t) => {
+          const schema = t.inputSchema ?? {};
+          const desc = t.description ?? "";
+          return {
+            name: t.name,
+            tokens: estimate(t.name) + estimate(desc) + estimate(stringifyContent(schema))
+          };
+        });
+        const toolTokens = toolBreakdown.reduce((a, b) => a + b.tokens, 0);
+        const messageBreakdown = context.messages.map((m, i) => {
+          let tk = 0;
+          if (typeof m.content === "string") {
+            tk = estimate(m.content);
+          } else if (Array.isArray(m.content)) {
+            for (const b of m.content) {
+              if (b.type === "text") tk += estimate(b.text ?? "");
+              else if (b.type === "tool_use") tk += estimate(stringifyContent(b.input));
+              else if (b.type === "tool_result") tk += estimate(stringifyContent(b.content));
+              else tk += estimate(stringifyContent(b));
+            }
+          }
+          return {
+            index: i,
+            role: m.role,
+            tokens: tk,
+            preview: typeof m.content === "string" ? m.content.slice(0, 60) : Array.isArray(m.content) ? m.content.map(
+              (b) => b.type === "text" ? (b.text ?? "").slice(0, 40) : b.type === "tool_use" ? `[tool_use: ${b.name}]` : b.type === "tool_result" ? `[tool_result]` : `[${b.type}]`
+            ).join(" ").slice(0, 60) : ""
+          };
+        });
+        const msgTokens = messageBreakdown.reduce((a, b) => a + b.tokens, 0);
+        const total = sysTokens + toolTokens + msgTokens;
+        send(ws, {
+          type: "context.debug",
+          payload: {
+            total,
+            systemPrompt: sysTokens,
+            tools: { total: toolTokens, count: tools.length, breakdown: toolBreakdown },
+            messages: { total: msgTokens, count: context.messages.length, breakdown: messageBreakdown }
+          }
+        });
+        break;
+      }
+      case "context.compact": {
+        const aggressive = !!msg.payload?.aggressive;
+        try {
+          const report = await compactor.compact(context, { aggressive });
+          send(ws, {
+            type: "context.compacted",
+            payload: {
+              before: report.before,
+              after: report.after,
+              saved: Math.max(0, report.before - report.after),
+              reductions: report.reductions
+            }
+          });
+          sendResult(
+            ws,
+            true,
+            `Compacted: ${report.before} \u2192 ${report.after} tokens (saved ~${Math.max(0, report.before - report.after)})`
+          );
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "providers.list": {
+        const providers = await modelsRegistry.listProviders();
+        const savedIds = new Set(Object.keys(config.providers ?? {}));
+        send(ws, {
+          type: "provider.catalog",
+          payload: {
+            providers: providers.map((p) => ({
+              id: p.id,
+              name: p.name,
+              family: p.family,
+              apiBase: p.apiBase,
+              envVars: p.envVars,
+              modelCount: p.models.length,
+              hasApiKey: savedIds.has(p.id) || p.envVars.some((v) => !!process.env[v])
+            }))
+          }
+        });
+        break;
+      }
+      case "provider.models": {
+        const providerId = msg.payload.providerId;
+        const provider2 = await modelsRegistry.getProvider(providerId);
+        if (provider2) {
+          send(ws, {
+            type: "provider.models",
+            payload: {
+              provider: providerId,
+              models: provider2.models.map((m) => ({
+                id: m.id,
+                name: m.name,
+                releaseDate: m.release_date,
+                contextWindow: m.limit?.context,
+                inputCost: m.cost?.input,
+                outputCost: m.cost?.output,
+                capabilities: [
+                  ...m.tool_call ? ["tools"] : [],
+                  ...m.reasoning ? ["reasoning"] : []
+                ]
+              }))
+            }
+          });
+        }
+        break;
+      }
+      case "model.switch": {
+        const { provider: newProvider, model: newModel } = msg.payload;
+        try {
+          config = patchConfig(config, { provider: newProvider, model: newModel });
+          configStore.update({ provider: newProvider, model: newModel });
+          context.model = newModel;
+          const providerCfg = config.providers?.[newProvider] ?? { type: newProvider };
+          const newProv = providerRegistry.has(newProvider) ? providerRegistry.create({ ...providerCfg, type: newProvider }) : makeProviderFromConfig(newProvider, providerCfg);
+          context.provider = newProv;
+          try {
+            const raw = await fs.readFile(globalConfigPath, "utf8");
+            const parsed = JSON.parse(raw);
+            parsed.provider = newProvider;
+            parsed.model = newModel;
+            await atomicWrite(globalConfigPath, JSON.stringify(parsed, null, 2));
+          } catch (err) {
+            console.warn("[WebUI] Failed to save config:", err);
+          }
+          send(ws, {
+            type: "key.operation_result",
+            payload: { success: true, message: `Switched to ${newProvider} / ${newModel}` }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "key.operation_result",
+            payload: {
+              success: false,
+              message: `Switch failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          });
+          break;
+        }
+        broadcast({ type: "session.start", payload: await sessionStartPayload() });
+        break;
+      }
+      case "key.add":
+      case "key.update": {
+        const { providerId, label, apiKey } = msg.payload;
+        await handleKeyUpsert(ws, providerId, label, apiKey);
+        break;
+      }
+      case "key.delete": {
+        const { providerId, label } = msg.payload;
+        await handleKeyDelete(ws, providerId, label);
+        break;
+      }
+      case "key.set_active": {
+        const { providerId, label } = msg.payload;
+        await handleKeySetActive(ws, providerId, label);
+        break;
+      }
+      case "provider.add": {
+        const p = msg.payload;
+        await handleProviderAdd(ws, p);
+        break;
+      }
+      case "provider.remove": {
+        const { providerId } = msg.payload;
+        await handleProviderRemove(ws, providerId);
+        break;
+      }
+      case "providers.saved": {
+        try {
+          const providers = await loadSavedProviders();
+          send(ws, {
+            type: "providers.saved",
+            payload: {
+              providers: Object.entries(providers).map(([id, cfg]) => ({
+                id,
+                family: cfg.family,
+                baseUrl: cfg.baseUrl,
+                apiKeys: normalizeKeys(cfg).map((k) => ({
+                  label: k.label,
+                  maskedKey: maskedKey(k.apiKey),
+                  isActive: k.label === cfg.activeKey,
+                  createdAt: k.createdAt ?? ""
+                }))
+              }))
+            }
+          });
+        } catch {
+          send(ws, { type: "providers.saved", payload: { providers: [] } });
+        }
+        break;
+      }
+      case "sessions.list": {
+        const limit = msg.payload?.limit ?? 50;
+        try {
+          const list = await sessionStore.list(limit);
+          send(ws, {
+            type: "sessions.list",
+            payload: {
+              sessions: list.map((s) => ({
+                id: s.id,
+                title: s.title,
+                startedAt: s.startedAt,
+                model: s.model,
+                provider: s.provider,
+                tokenTotal: s.tokenTotal,
+                isCurrent: s.id === session.id
+              }))
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "sessions.list",
+            payload: { sessions: [], error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+        break;
+      }
+      case "session.delete": {
+        const { id } = msg.payload;
+        try {
+          if (id === session.id) {
+            sendResult(ws, false, "Cannot delete the active session");
+            break;
+          }
+          await sessionStore.delete(id);
+          sendResult(ws, true, `Session ${id} deleted`);
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "session.resume": {
+        const { id } = msg.payload;
+        try {
+          if (id === session.id) {
+            sendResult(ws, false, "Session is already active");
+            break;
+          }
+          const resumed = await sessionStore.resume(id);
+          try {
+            await session.close();
+          } catch {
+          }
+          session = resumed.writer;
+          context.session = session;
+          context.state.replaceMessages(resumed.data.messages);
+          context.readFiles.clear();
+          context.fileMtimes.clear();
+          tokenCounter.reset();
+          tokenCounter.account(resumed.data.usage, config.model);
+          sessionStartedAt = Date.now();
+          broadcast({
+            type: "session.start",
+            payload: {
+              ...await sessionStartPayload(),
+              reset: true,
+              replayMessages: resumed.data.messages,
+              replayUsage: resumed.data.usage
+            }
+          });
+          sendResult(ws, true, `Resumed session ${id}`);
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "session.save": {
+        sendResult(ws, true, `Session ${session.id} is auto-saved`);
+        break;
+      }
+      case "tools.list": {
+        const list = toolRegistry.list().map((t) => {
+          const schema = t.inputSchema ?? {};
+          const params = schema.properties ? Object.keys(schema.properties) : [];
+          return {
+            name: t.name,
+            description: t.description ?? "",
+            params
+          };
+        });
+        send(ws, { type: "tools.list", payload: { tools: list } });
+        break;
+      }
+      case "memory.list": {
+        try {
+          const text = await memoryStore.readAll();
+          send(ws, { type: "memory.list", payload: { text } });
+        } catch (err) {
+          send(ws, {
+            type: "memory.list",
+            payload: { text: "", error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+        break;
+      }
+      case "memory.remember": {
+        const { text, scope } = msg.payload;
+        try {
+          await memoryStore.remember(text, scope ?? "project-memory");
+          sendResult(ws, true, "Saved to memory");
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "memory.forget": {
+        const { text, scope } = msg.payload;
+        try {
+          const removed = await memoryStore.forget(text, scope ?? "project-memory");
+          sendResult(ws, removed > 0, removed > 0 ? `Removed ${removed} entr${removed === 1 ? "y" : "ies"}` : "No matching entries");
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "skills.list": {
+        if (!skillLoader) {
+          send(ws, { type: "skills.list", payload: { skills: [], enabled: false } });
+          break;
+        }
+        try {
+          const manifests = await skillLoader.list();
+          const entries = await skillLoader.listEntries();
+          const byName = new Map(entries.map((e) => [e.name, e]));
+          send(ws, {
+            type: "skills.list",
+            payload: {
+              enabled: true,
+              skills: manifests.map((m) => ({
+                name: m.name,
+                description: m.description,
+                version: m.version ?? "",
+                source: m.source,
+                path: m.path,
+                trigger: byName.get(m.name)?.trigger ?? "",
+                scope: byName.get(m.name)?.scope ?? []
+              }))
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "skills.list",
+            payload: { skills: [], enabled: true, error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+        break;
+      }
+      case "diag.get": {
+        const usage = tokenCounter.total();
+        send(ws, {
+          type: "diag.get",
+          payload: {
+            provider: config.provider,
+            model: config.model,
+            cwd: projectRoot,
+            sessionId: session.id,
+            tools: {
+              count: toolRegistry.list().length,
+              names: toolRegistry.list().map((t) => t.name)
+            },
+            features: {
+              memory: !!config.features?.memory,
+              skills: !!config.features?.skills,
+              modelsRegistry: !!config.features?.modelsRegistry
+            },
+            mode: modeId ?? "default",
+            usage,
+            messages: context.messages.length,
+            todos: context.todos.length
+          }
+        });
+        break;
+      }
+      case "todos.get": {
+        send(ws, {
+          type: "todos.updated",
+          payload: { todos: [...context.todos] }
+        });
+        break;
+      }
+      case "todos.clear": {
+        context.todos.length = 0;
+        sendResult(ws, true, "Todos cleared");
+        broadcast({ type: "todos.updated", payload: { todos: [] } });
+        break;
+      }
+      case "files.list": {
+        const payload = msg.payload ?? {};
+        const query = (payload.query ?? "").toLowerCase();
+        const limit = payload.limit ?? 50;
+        const SKIP_DIRS = /* @__PURE__ */ new Set([
+          ".git",
+          "node_modules",
+          "dist",
+          "build",
+          ".next",
+          ".turbo",
+          ".cache",
+          "target",
+          "coverage",
+          ".nyc_output",
+          "out",
+          ".pnpm-store",
+          ".parcel-cache"
+        ]);
+        const results = [];
+        async function walk(dir, rel, depth) {
+          if (depth > 8 || results.length >= 600) return;
+          let entries = [];
+          try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+          } catch {
+            return;
+          }
+          for (const e of entries) {
+            if (results.length >= 600) return;
+            if (e.name.startsWith(".") && e.name !== ".wrongstack" && e.name !== ".env.example") {
+              if (e.name !== ".gitignore" && e.name !== ".eslintrc" && e.name !== ".prettierrc") continue;
+            }
+            const childRel = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+              if (SKIP_DIRS.has(e.name)) continue;
+              await walk(path.join(dir, e.name), childRel, depth + 1);
+            } else if (e.isFile()) {
+              results.push(childRel);
+            }
+          }
+        }
+        await walk(projectRoot, "", 0);
+        const scored = [];
+        for (const p of results) {
+          if (!query) {
+            scored.push({ path: p, score: 0 });
+            continue;
+          }
+          const lower = p.toLowerCase();
+          const base = lower.split("/").pop() ?? lower;
+          let score = 0;
+          if (base === query) score = 100;
+          else if (base.startsWith(query)) score = 60;
+          else if (lower.includes(query)) score = 20;
+          else continue;
+          score -= p.split("/").length;
+          scored.push({ path: p, score });
+        }
+        scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+        send(ws, {
+          type: "files.list",
+          payload: { files: scored.slice(0, limit).map((s) => s.path) }
+        });
+        break;
+      }
+      case "modes.list": {
+        try {
+          const modes = await modeStore.listModes();
+          const active = await modeStore.getActiveMode();
+          send(ws, {
+            type: "modes.list",
+            payload: {
+              modes: modes.map((m) => ({
+                id: m.id,
+                name: m.name,
+                description: m.description,
+                isActive: m.id === (active?.id ?? "default")
+              })),
+              activeId: active?.id ?? "default"
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "modes.list",
+            payload: { modes: [], activeId: "default", error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+        break;
+      }
+      case "mode.switch": {
+        const { id } = msg.payload;
+        try {
+          if (id === "default") {
+            await modeStore.setActiveMode(null);
+          } else {
+            const found = await modeStore.getMode(id);
+            if (!found) throw new Error(`Unknown mode "${id}"`);
+            await modeStore.setActiveMode(id);
+          }
+          modeId = id;
+          sendResult(ws, true, `Switched to mode "${id}"`);
+          broadcast({
+            type: "session.start",
+            payload: { ...await sessionStartPayload() }
+          });
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "stats.get": {
+        const usage = tokenCounter.total();
+        const cacheStats = tokenCounter.cacheStats();
+        const m = await modelsRegistry.getModel(config.provider, config.model).catch(() => null);
+        const inputCost = m?.cost?.input ?? 0;
+        const outputCost = m?.cost?.output ?? 0;
+        const cacheReadCost = m?.cost?.cache_read ?? 0;
+        const cost = (usage.input * inputCost + usage.output * outputCost + (usage.cacheRead ?? 0) * cacheReadCost) / 1e6;
+        send(ws, {
+          type: "stats.get",
+          payload: {
+            sessionId: session.id,
+            provider: config.provider,
+            model: config.model,
+            usage,
+            cache: cacheStats,
+            cost,
+            messages: context.messages.length,
+            readFiles: context.readFiles.size,
+            tools: toolRegistry.list().length,
+            elapsedMs: Date.now() - sessionStartedAt
+          }
+        });
+        break;
+      }
+    }
+  }
+  async function loadSavedProviders() {
+    try {
+      const raw = await fs.readFile(globalConfigPath, "utf8");
+      const parsed = JSON.parse(raw);
+      return parsed.providers ?? {};
+    } catch {
+      return {};
+    }
+  }
+  async function saveProviders(providers) {
+    let parsed;
+    try {
+      const raw = await fs.readFile(globalConfigPath, "utf8");
+      parsed = JSON.parse(raw);
+    } catch {
+      parsed = {};
+    }
+    parsed["providers"] = providers;
+    await atomicWrite(globalConfigPath, JSON.stringify(parsed, null, 2), { mode: 384 });
+  }
+  function normalizeKeys(cfg) {
+    if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
+      return cfg.apiKeys.map((k) => ({ ...k }));
+    }
+    if (typeof cfg.apiKey === "string" && cfg.apiKey.length > 0) {
+      return [{ label: "default", apiKey: cfg.apiKey, createdAt: "" }];
+    }
+    return [];
+  }
+  function writeKeysBack(cfg, keys) {
+    if (keys.length === 0) {
+      delete cfg.apiKeys;
+      delete cfg.apiKey;
+      delete cfg.activeKey;
+      return;
+    }
+    cfg.apiKeys = keys;
+    const active = keys.find((k) => k.label === cfg.activeKey) ?? keys[0];
+    cfg.apiKey = active.apiKey;
+    if (!cfg.activeKey || !keys.some((k) => k.label === cfg.activeKey)) {
+      cfg.activeKey = active.label;
+    }
+  }
+  function maskedKey(key) {
+    if (!key) return "\u2014";
+    if (key.length <= 8) return "\u2022".repeat(key.length);
+    return `${key.slice(0, 4)}\u2026${key.slice(-4)}`;
+  }
+  function sendResult(ws, success, message) {
+    send(ws, { type: "key.operation_result", payload: { success, message } });
+  }
+  async function handleKeyUpsert(ws, providerId, label, apiKey) {
+    try {
+      const providers = await loadSavedProviders();
+      const existing = providers[providerId] ?? { type: providerId };
+      const keys = normalizeKeys(existing);
+      const idx = keys.findIndex((k) => k.label === label);
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      if (idx >= 0) {
+        keys[idx] = { ...keys[idx], apiKey, createdAt: nowIso };
+      } else {
+        keys.push({ label, apiKey, createdAt: nowIso });
+      }
+      writeKeysBack(existing, keys);
+      if (!existing.activeKey) existing.activeKey = label;
+      providers[providerId] = existing;
+      await saveProviders(providers);
+      sendResult(ws, true, `Key "${label}" saved for ${providerId}`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleKeyDelete(ws, providerId, label) {
+    try {
+      const providers = await loadSavedProviders();
+      const existing = providers[providerId];
+      if (!existing) {
+        sendResult(ws, false, `Provider "${providerId}" not found`);
+        return;
+      }
+      const keys = normalizeKeys(existing).filter((k) => k.label !== label);
+      if (keys.length === 0) {
+        delete providers[providerId];
+      } else {
+        writeKeysBack(existing, keys);
+        if (existing.activeKey === label) existing.activeKey = keys[0].label;
+        providers[providerId] = existing;
+      }
+      await saveProviders(providers);
+      sendResult(ws, true, `Key "${label}" deleted from ${providerId}`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleKeySetActive(ws, providerId, label) {
+    try {
+      const providers = await loadSavedProviders();
+      const existing = providers[providerId];
+      if (!existing) {
+        sendResult(ws, false, `Provider "${providerId}" not found`);
+        return;
+      }
+      existing.activeKey = label;
+      writeKeysBack(existing, normalizeKeys(existing));
+      providers[providerId] = existing;
+      await saveProviders(providers);
+      sendResult(ws, true, `Active key for ${providerId} set to "${label}"`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleProviderAdd(ws, payload) {
+    try {
+      const providers = await loadSavedProviders();
+      if (providers[payload.id]) {
+        sendResult(ws, false, `Provider "${payload.id}" already exists. Use key.add to add a key.`);
+        return;
+      }
+      const newProv = {
+        type: payload.id,
+        family: payload.family,
+        baseUrl: payload.baseUrl
+      };
+      if (payload.apiKey) {
+        newProv.apiKeys = [{ label: "default", apiKey: payload.apiKey, createdAt: (/* @__PURE__ */ new Date()).toISOString() }];
+        newProv.activeKey = "default";
+      }
+      providers[payload.id] = newProv;
+      await saveProviders(providers);
+      sendResult(ws, true, `Provider "${payload.id}" added`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleProviderRemove(ws, providerId) {
+    try {
+      const providers = await loadSavedProviders();
+      if (!providers[providerId]) {
+        sendResult(ws, false, `Provider "${providerId}" not found`);
+        return;
+      }
+      delete providers[providerId];
+      await saveProviders(providers);
+      sendResult(ws, true, `Provider "${providerId}" removed`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  const shutdown = async () => {
+    console.log("[WebUI] Shutting down...");
+    try {
+      await session.append({ type: "session_end", ts: (/* @__PURE__ */ new Date()).toISOString(), usage: tokenCounter.total() });
+      await session.close();
+    } catch (e) {
+      console.warn("[WebUI] Error closing session:", e);
+    }
+    for (const [ws] of clients) ws.close();
+    wssPrimary.close();
+    wssSecondary?.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+export {
+  startWebUI
+};
+//# sourceMappingURL=index.js.map