hypercore-cli 1.1.0

package/dist/chunk-AUHU7ALH.js

@@ -0,0 +1,2023 @@
+import {
+  attachWebSocket
+} from "./chunk-2LJ2DVEB.js";
+import {
+  addMember,
+  addTask,
+  createTeam,
+  deleteTask,
+  findTeamByJoinCode,
+  listRuns,
+  listTasks,
+  loadRun,
+  loadTeam,
+  updateTask
+} from "./chunk-6OL3GA3P.js";
+import {
+  deleteSession,
+  exportSession,
+  generateSessionId,
+  listSessions,
+  loadSession,
+  saveSession
+} from "./chunk-XOS6HPEF.js";
+import {
+  validateToken
+} from "./chunk-XDRCBMZZ.js";
+import {
+  Engine,
+  HYPERCORE_DIR,
+  initializeWorkspace
+} from "./chunk-MV4TTRYX.js";
+import {
+  createToolRegistry
+} from "./chunk-IXOIOGR5.js";
+import {
+  estimateCost,
+  formatCost
+} from "./chunk-R3GPQC7I.js";
+import {
+  createLLMClient,
+  streamCallLLM
+} from "./chunk-43OLRXM5.js";
+import {
+  createOpenAIClient,
+  streamOpenAIChat
+} from "./chunk-GOOTEPBK.js";
+import {
+  hookManager
+} from "./chunk-B6A2AKLN.js";
+import {
+  HYPERCORE_DIR as HYPERCORE_DIR2,
+  loadConfig
+} from "./chunk-V5UHPPSY.js";
+import {
+  listLines
+} from "./chunk-WHLVZCQY.js";
+
+// src/web/server.ts
+import http from "http";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/git.ts
+import { execFileSync } from "child_process";
+function gitExec(args, cwd) {
+  try {
+    return execFileSync("git", args, {
+      encoding: "utf-8",
+      cwd: cwd || process.cwd(),
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch (err) {
+    const error = err;
+    throw new Error(error.stderr?.trim() || error.message || "git \u547D\u4EE4\u5931\u8D25");
+  }
+}
+function gitExecSafe(args, cwd) {
+  try {
+    return gitExec(args, cwd);
+  } catch {
+    return "";
+  }
+}
+function isGitRepo() {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function gitBranch() {
+  return gitExecSafe(["branch", "--show-current"]) || "HEAD";
+}
+function gitStatus() {
+  const output = gitExecSafe(["status", "--porcelain"]);
+  if (!output) return { staged: [], modified: [], untracked: [], deleted: [] };
+  const staged = [];
+  const modified = [];
+  const untracked = [];
+  const deleted = [];
+  for (const line of output.split("\n")) {
+    if (!line || line.length < 3) continue;
+    const x = line[0];
+    const y = line[1];
+    const file = line.slice(3);
+    if ("MADRC".includes(x) && x !== " " && x !== "?") {
+      staged.push(file);
+    }
+    if (y === "M") {
+      modified.push(file);
+    }
+    if (y === "D" || x === "D") {
+      deleted.push(file);
+    }
+    if (x === "?" && y === "?") {
+      untracked.push(file);
+    }
+  }
+  return { staged, modified, untracked, deleted };
+}
+function gitStatusSummary() {
+  const s = gitStatus();
+  const parts = [];
+  if (s.staged.length) parts.push(`${s.staged.length} staged`);
+  if (s.modified.length) parts.push(`${s.modified.length} modified`);
+  if (s.untracked.length) parts.push(`${s.untracked.length} untracked`);
+  if (s.deleted.length) parts.push(`${s.deleted.length} deleted`);
+  return parts.length > 0 ? parts.join(", ") : "clean";
+}
+function gitDiffStaged() {
+  return gitExecSafe(["diff", "--cached"]);
+}
+function gitDiffStagedStat() {
+  return gitExecSafe(["diff", "--cached", "--stat"]);
+}
+function gitDiffUnstaged() {
+  return gitExecSafe(["diff"]);
+}
+function gitLog(n = 10) {
+  const output = gitExecSafe(["log", "--oneline", `--format=%H|%h|%s|%ai|%an`, `-${n}`]);
+  if (!output) return [];
+  return output.split("\n").filter(Boolean).map((line) => {
+    const [hash, shortHash, message, date, author] = line.split("|");
+    return { hash, shortHash, message, date, author };
+  });
+}
+function gitDiffFiles(base, head = "HEAD") {
+  return gitExecSafe(["diff", "--name-only", `${base}...${head}`]);
+}
+function gitDiffRange(base, head = "HEAD") {
+  return gitExecSafe(["diff", "--stat", `${base}...${head}`]);
+}
+function gitStageFiles(files) {
+  if (files.length === 0) return;
+  gitExec(["add", "--", ...files]);
+}
+function gitCommit(message) {
+  return gitExec(["commit", "-m", message]);
+}
+function gitCreateBranch(name) {
+  gitExec(["checkout", "-b", name]);
+}
+function gitPushUpstream(remote = "origin", branch) {
+  const branchName = branch || gitBranch();
+  return gitExec(["push", "-u", remote, branchName]);
+}
+function gitDefaultBranch() {
+  const remoteHead = gitExecSafe(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+  if (remoteHead) {
+    return remoteHead.replace("refs/remotes/origin/", "");
+  }
+  const branches = gitExecSafe(["branch", "-a"]);
+  if (branches.includes("main")) return "main";
+  if (branches.includes("master")) return "master";
+  return "main";
+}
+function hasUncommittedChanges() {
+  const output = gitExecSafe(["status", "--porcelain"]);
+  return output.length > 0;
+}
+function gitHeadShort() {
+  return gitExecSafe(["rev-parse", "--short", "HEAD"]);
+}
+function gitListBranches() {
+  const output = gitExecSafe(["branch", "--format=%(refname:short)|%(HEAD)"]);
+  if (!output) return [];
+  return output.split("\n").filter(Boolean).map((line) => {
+    const [name, head] = line.split("|");
+    return { name: name.trim(), current: head.trim() === "*" };
+  });
+}
+function gitSwitchBranch(name) {
+  return gitExec(["switch", name]);
+}
+function gitDeleteBranch(name, force = false) {
+  return gitExec(["branch", force ? "-D" : "-d", name]);
+}
+function gitStash(message) {
+  const args = ["stash", "push"];
+  if (message) args.push("-m", message);
+  return gitExec(args);
+}
+function gitStashPop(index) {
+  const args = ["stash", "pop"];
+  if (index !== void 0) args.push(`stash@{${index}}`);
+  return gitExec(args);
+}
+function gitStashList() {
+  return gitExecSafe(["stash", "list"]);
+}
+function gitStashDrop(index) {
+  const args = ["stash", "drop"];
+  if (index !== void 0) args.push(`stash@{${index}}`);
+  return gitExec(args);
+}
+function gitDiffFile(file, staged = false) {
+  const args = ["diff"];
+  if (staged) args.push("--cached");
+  args.push("--", file);
+  return gitExecSafe(args);
+}
+function gitWorktreeAdd(path2, branch, createBranch = false) {
+  const args = ["worktree", "add"];
+  if (createBranch) args.push("-b", branch, path2);
+  else args.push(path2, branch);
+  return gitExec(args);
+}
+function gitWorktreeList() {
+  return gitExecSafe(["worktree", "list"]);
+}
+function gitWorktreeRemove(path2, force = false) {
+  const args = ["worktree", "remove"];
+  if (force) args.push("--force");
+  args.push(path2);
+  return gitExec(args);
+}
+
+// src/web/api.ts
+import { readdir, readFile, stat, writeFile } from "fs/promises";
+import { join, resolve, relative, isAbsolute } from "path";
+import { existsSync } from "fs";
+
+// src/web/repl-bridge.ts
+import { WebSocketServer, WebSocket } from "ws";
+import { EventEmitter } from "events";
+var InputMultiplexer = class extends EventEmitter {
+  rl;
+  guiQueue = [];
+  waiting = null;
+  constructor(rl) {
+    super();
+    this.rl = rl;
+  }
+  /** 从 GUI WebSocket 推入输入 */
+  pushGUIInput(content) {
+    if (this.waiting) {
+      const resolve2 = this.waiting;
+      this.waiting = null;
+      resolve2({ source: "gui", content });
+    } else {
+      this.guiQueue.push(content);
+    }
+  }
+  /** 等待下一个输入（来自 CLI 或 GUI） */
+  nextInput(prompt) {
+    if (this.guiQueue.length > 0) {
+      const content = this.guiQueue.shift();
+      return Promise.resolve({ source: "gui", content });
+    }
+    return new Promise((resolve2) => {
+      let settled = false;
+      const cleanup = () => {
+        settled = true;
+        this.waiting = null;
+      };
+      this.rl.question(prompt, (answer) => {
+        if (settled) return;
+        cleanup();
+        resolve2({ source: "cli", content: answer });
+      });
+      this.waiting = (input) => {
+        if (settled) return;
+        cleanup();
+        process.stdout.write("\r\x1B[K");
+        resolve2(input);
+      };
+    });
+  }
+};
+var guiClients = [];
+var replContext = null;
+var multiplexer = null;
+var clientIdCounter = 0;
+function emitToGUI(type, payload = {}) {
+  const msg = {
+    type,
+    payload,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "cli"
+  };
+  const data = JSON.stringify(msg);
+  for (const client of guiClients) {
+    if (client.ws.readyState === WebSocket.OPEN) {
+      client.ws.send(data);
+    }
+  }
+}
+function registerREPLContext(ctx) {
+  replContext = ctx;
+}
+function getREPLContext() {
+  return replContext;
+}
+function createMultiplexer(rl) {
+  multiplexer = new InputMultiplexer(rl);
+  return multiplexer;
+}
+function hasGUIClients() {
+  return guiClients.length > 0;
+}
+function buildStateSnapshot() {
+  if (!replContext) return {};
+  return {
+    sessionId: replContext.sessionId,
+    model: replContext.config.modelConfig.model,
+    provider: replContext.config.modelConfig.provider,
+    tokens: replContext.sessionTokens,
+    toolCount: replContext.tools.length,
+    tools: replContext.tools.map((t) => ({
+      name: t.definition.name,
+      description: t.definition.description?.slice(0, 100)
+    })),
+    chatHistory: replContext.chatHistory.map((m) => ({
+      role: m.role,
+      content: m.content.slice(0, 2e3)
+    })),
+    cwd: process.cwd()
+  };
+}
+function handleGUIMessage(clientId, raw) {
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const payload = msg.payload || {};
+  switch (msg.type) {
+    case "user_input": {
+      const content = payload.content;
+      if (content && multiplexer) {
+        multiplexer.pushGUIInput(content);
+      }
+      break;
+    }
+    case "slash_command": {
+      const command = payload.command;
+      if (command && multiplexer) {
+        multiplexer.pushGUIInput(command.startsWith("/") ? command : `/${command}`);
+      }
+      break;
+    }
+    case "state_request": {
+      const snapshot = buildStateSnapshot();
+      const client = guiClients.find((c) => c.id === clientId);
+      if (client && client.ws.readyState === WebSocket.OPEN) {
+        const response = {
+          type: "state_sync",
+          payload: snapshot,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          source: "cli"
+        };
+        client.ws.send(JSON.stringify(response));
+      }
+      break;
+    }
+    case "heartbeat": {
+      const client = guiClients.find((c) => c.id === clientId);
+      if (client && client.ws.readyState === WebSocket.OPEN) {
+        const pong = {
+          type: "heartbeat",
+          payload: { pong: true },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          source: "cli"
+        };
+        client.ws.send(JSON.stringify(pong));
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+function attachREPLBridge(_server) {
+  const wss = new WebSocketServer({ noServer: true });
+  wss.on("connection", (ws) => {
+    const id = `gui_${++clientIdCounter}`;
+    const client = {
+      ws,
+      id,
+      connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    guiClients.push(client);
+    const connected = {
+      type: "connected",
+      payload: {
+        clientId: id,
+        state: buildStateSnapshot()
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "cli"
+    };
+    ws.send(JSON.stringify(connected));
+    ws.on("message", (data) => {
+      handleGUIMessage(id, data.toString());
+    });
+    ws.on("close", () => {
+      guiClients = guiClients.filter((c) => c.id !== id);
+    });
+    ws.on("error", (err) => {
+      console.error(`[REPL Bridge] GUI \u8FDE\u63A5\u9519\u8BEF (${id}):`, err.message);
+    });
+  });
+  return wss;
+}
+
+// src/core/workspace-generator.ts
+import { randomBytes } from "crypto";
+var NEED_TO_LINES = {
+  "content-writing": ["\u516C\u4F17\u53F7\u6587\u7AE0", "\u5C0F\u7EA2\u4E66\u7B14\u8BB0"],
+  "research": ["\u7ADE\u54C1\u5206\u6790", "\u70ED\u70B9\u8FFD\u8E2A"],
+  "reports": ["\u5468\u62A5\u751F\u6210"],
+  "social-media": ["\u5C0F\u7EA2\u4E66\u7B14\u8BB0"],
+  "competitor-analysis": ["\u7ADE\u54C1\u5206\u6790"],
+  "meeting-notes": ["\u4F1A\u8BAE\u7EAA\u8981"],
+  "data-analysis": [],
+  "customer-outreach": []
+};
+var NEED_TO_AGENTS = {
+  "content-writing": ["\u5199\u624B", "\u7B56\u5212\u5E08"],
+  "research": ["\u8C03\u7814\u5458"],
+  "reports": ["\u5199\u624B"],
+  "social-media": ["\u5199\u624B", "\u7B56\u5212\u5E08"],
+  "competitor-analysis": ["\u8C03\u7814\u5458"],
+  "meeting-notes": ["\u5199\u624B"],
+  "data-analysis": ["\u8C03\u7814\u5458"],
+  "customer-outreach": ["\u5199\u624B", "\u7B56\u5212\u5E08"]
+};
+var NEED_TO_SKILLS = {
+  "content-writing": ["\u516C\u4F17\u53F7\u5199\u4F5C", "\u5C0F\u7EA2\u4E66\u5199\u4F5C"],
+  "research": ["\u5E02\u573A\u8C03\u7814", "\u7ADE\u54C1\u5206\u6790", "\u70ED\u70B9\u8FFD\u8E2A"],
+  "reports": [],
+  "social-media": ["\u5C0F\u7EA2\u4E66\u5199\u4F5C"],
+  "competitor-analysis": ["\u7ADE\u54C1\u5206\u6790"],
+  "meeting-notes": [],
+  "data-analysis": [],
+  "customer-outreach": []
+};
+var INDUSTRY_LABELS = {
+  "marketing": "\u8425\u9500\u5DE5\u4F5C\u7AD9",
+  "ecommerce": "\u7535\u5546\u4E2D\u5FC3",
+  "education": "\u5B66\u4E60\u5B9E\u9A8C\u5BA4",
+  "tech": "\u6280\u672F\u5DE5\u574A",
+  "finance": "\u5206\u6790\u5DE5\u4F5C\u53F0",
+  "media": "\u5185\u5BB9\u5DE5\u4F5C\u5BA4",
+  "consulting": "\u54A8\u8BE2\u5957\u4EF6",
+  "other": "\u667A\u80FD\u5DE5\u4F5C\u53F0"
+};
+var ROLE_TITLES = {
+  "founder": "\u521B\u59CB\u4EBA",
+  "marketer": "\u8425\u9500\u5B98",
+  "content-creator": "\u521B\u4F5C\u8005",
+  "product-manager": "\u4EA7\u54C1\u7ECF\u7406",
+  "researcher": "\u7814\u7A76\u5458",
+  "operations": "\u8FD0\u8425\u5B98",
+  "freelancer": "\u81EA\u7531\u804C\u4E1A\u8005"
+};
+function generateQuickCommands(industry, role, needs) {
+  const commands = [];
+  const safeNeeds = Array.isArray(needs) ? needs : [];
+  commands.push({ label: "\u65B0\u5BF9\u8BDD", icon: "\u{1F4AC}", cmd: "/new" });
+  if (safeNeeds.length === 0) {
+    commands.push({ label: "\u641C\u7D22\u8BB0\u5FC6", icon: "\u{1F9E0}", cmd: "/recall" });
+    commands.push({ label: "\u67E5\u770B\u8D39\u7528", icon: "\u{1F4B0}", cmd: "/cost" });
+    return commands;
+  }
+  if (safeNeeds.includes("content-writing")) {
+    commands.push({ label: "\u5199\u516C\u4F17\u53F7", icon: "\u270D\uFE0F", cmd: "/run \u516C\u4F17\u53F7\u6587\u7AE0" });
+  }
+  if (safeNeeds.includes("social-media") || safeNeeds.includes("content-writing")) {
+    commands.push({ label: "\u5199\u5C0F\u7EA2\u4E66", icon: "\u{1F4F1}", cmd: "/run \u5C0F\u7EA2\u4E66\u7B14\u8BB0" });
+  }
+  if (safeNeeds.includes("research") || safeNeeds.includes("competitor-analysis")) {
+    commands.push({ label: "\u7ADE\u54C1\u5206\u6790", icon: "\u{1F50D}", cmd: "/run \u7ADE\u54C1\u5206\u6790" });
+  }
+  if (safeNeeds.includes("reports")) {
+    commands.push({ label: "\u751F\u6210\u5468\u62A5", icon: "\u{1F4CA}", cmd: "/run \u5468\u62A5\u751F\u6210" });
+  }
+  if (industry === "ecommerce" && commands.length < 5) {
+    commands.push({ label: "Listing\u6587\u6848", icon: "\u{1F6D2}", cmd: '/run \u516C\u4F17\u53F7\u6587\u7AE0 --topic "\u4EA7\u54C1Listing\u4F18\u5316"' });
+  }
+  if (industry === "media" && commands.length < 5) {
+    commands.push({ label: "\u70ED\u70B9\u8FFD\u8E2A", icon: "\u{1F525}", cmd: "/run \u70ED\u70B9\u8FFD\u8E2A" });
+  }
+  if (industry === "tech" && commands.length < 5) {
+    commands.push({ label: "\u4EE3\u7801\u5BA1\u67E5", icon: "\u{1F527}", cmd: "/run \u4EE3\u7801\u5BA1\u67E5" });
+  }
+  if (commands.length < 3) {
+    commands.push({ label: "\u641C\u7D22\u8BB0\u5FC6", icon: "\u{1F9E0}", cmd: "/recall" });
+  }
+  return commands.slice(0, 5);
+}
+function generateWelcomeMessage(industry, role) {
+  const roleTitle = ROLE_TITLES[role] || "\u7528\u6237";
+  const label = INDUSTRY_LABELS[industry] || "\u667A\u80FD\u5DE5\u4F5C\u53F0";
+  const greetings = {
+    "founder": `\u6B22\u8FCE\u56DE\u6765\uFF0C${roleTitle}\u3002\u4F60\u7684${label}\u5DF2\u5C31\u7EEA\uFF0C\u51C6\u5907\u597D\u5F81\u670D\u5E02\u573A\u4E86\u5417\uFF1F`,
+    "marketer": `${roleTitle}\u4F60\u597D\uFF01${label}\u5DF2\u4E3A\u4F60\u5907\u9F50\u5DE5\u5177\uFF0C\u8BA9\u521B\u610F\u843D\u5730\u3002`,
+    "content-creator": `\u7075\u611F\u6765\u4E86\u5C31\u52A8\u7B14\uFF0C${roleTitle}\u3002${label}\u968F\u65F6\u652F\u63F4\u3002`,
+    "product-manager": `${roleTitle}\uFF0C${label}\u5DF2\u540C\u6B65\u6700\u65B0\u6570\u636E\uFF0C\u5F00\u59CB\u4ECA\u5929\u7684\u5DE5\u4F5C\u5427\u3002`,
+    "researcher": `${roleTitle}\uFF0C${label}\u5DF2\u5C31\u4F4D\u3002\u8BA9\u6570\u636E\u8BF4\u8BDD\u3002`,
+    "operations": `${roleTitle}\uFF0C${label}\u8FD0\u8F6C\u6B63\u5E38\u3002\u4ECA\u5929\u5904\u7406\u4EC0\u4E48\uFF1F`,
+    "freelancer": `\u81EA\u7531\u7684${roleTitle}\uFF0C${label}\u662F\u4F60\u7684\u9AD8\u6548\u540E\u76FE\u3002`
+  };
+  return greetings[role] || `\u6B22\u8FCE\u4F7F\u7528${label}\uFF0C\u4E00\u5207\u5C31\u7EEA\u3002`;
+}
+function generateWorkspaceProfile(answers) {
+  const { industry, role, teamSize, platforms } = answers;
+  const automationNeeds = Array.isArray(answers.automationNeeds) ? answers.automationNeeds : [];
+  const linesSet = /* @__PURE__ */ new Set();
+  const agentsSet = /* @__PURE__ */ new Set();
+  const skillsSet = /* @__PURE__ */ new Set();
+  for (const need of automationNeeds) {
+    (NEED_TO_LINES[need] || []).forEach((l) => linesSet.add(l));
+    (NEED_TO_AGENTS[need] || []).forEach((a) => agentsSet.add(a));
+    (NEED_TO_SKILLS[need] || []).forEach((s) => skillsSet.add(s));
+  }
+  const enabledModules = ["chat", "files", "memory", "tools", "team", "network"];
+  const workspaceLabel = INDUSTRY_LABELS[industry] || "\u667A\u80FD\u5DE5\u4F5C\u53F0";
+  const quickCommands = generateQuickCommands(industry, role, automationNeeds);
+  const welcomeMessage = generateWelcomeMessage(industry, role);
+  return {
+    id: randomBytes(8).toString("hex"),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    industry,
+    role,
+    automationNeeds,
+    teamSize,
+    platforms,
+    freeDescription: answers.freeDescription,
+    enabledModules,
+    recommendedLines: [...linesSet],
+    recommendedAgents: [...agentsSet],
+    recommendedSkills: [...skillsSet],
+    workspaceLabel,
+    quickCommands,
+    welcomeMessage
+  };
+}
+
+// src/web/api.ts
+function sendAttachment(res, content, filename, contentType) {
+  res.writeHead(200, {
+    "Content-Type": contentType,
+    "Content-Disposition": `attachment; filename="${filename}"`,
+    "Cache-Control": "no-cache, no-store, must-revalidate",
+    "Pragma": "no-cache",
+    "Expires": "0",
+    "Access-Control-Allow-Origin": `http://localhost:${getActivePort()}`,
+    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization"
+  });
+  res.end(content);
+}
+function sendAdminTestError(res, err, fallback = "\u6D4B\u8BD5\u63A5\u53E3\u8C03\u7528\u5931\u8D25") {
+  if (err && typeof err === "object" && "statusCode" in err) {
+    const e = err;
+    sendError(res, e.message || fallback, e.statusCode || 400);
+    return;
+  }
+  sendError(res, String(err));
+}
+async function handleApiRequest(req, res, config, pathname) {
+  const method = req.method || "GET";
+  if (pathname === "/api/sessions" && method === "GET") {
+    const sessions = await listSessions(50);
+    sendJSON(res, { sessions });
+    return;
+  }
+  const exportMatch = pathname.match(/^\/api\/sessions\/([^/]+)\/export$/);
+  if (exportMatch && method === "GET") {
+    try {
+      const markdown = await exportSession(exportMatch[1]);
+      res.writeHead(200, {
+        "Content-Type": "text/markdown; charset=utf-8",
+        "Content-Disposition": `attachment; filename="${exportMatch[1]}.md"`,
+        "Access-Control-Allow-Origin": `http://localhost:${getActivePort()}`
+      });
+      res.end(markdown);
+    } catch {
+      sendError(res, "Session not found", 404);
+    }
+    return;
+  }
+  const sessionMatch = pathname.match(/^\/api\/sessions\/([^/]+)$/);
+  if (sessionMatch) {
+    const sessionId = sessionMatch[1];
+    if (method === "GET") {
+      try {
+        const messages = await loadSession(sessionId);
+        sendJSON(res, { id: sessionId, messages });
+      } catch {
+        sendError(res, "Session not found", 404);
+      }
+      return;
+    }
+    if (method === "DELETE") {
+      try {
+        await deleteSession(sessionId);
+        sendJSON(res, { success: true });
+      } catch {
+        sendError(res, "Failed to delete session", 500);
+      }
+      return;
+    }
+  }
+  if (pathname === "/api/config" && method === "GET") {
+    const replCtx = getREPLContext();
+    if (replCtx) {
+      sendJSON(res, {
+        provider: replCtx.config.modelConfig.provider,
+        model: replCtx.config.modelConfig.model,
+        outputDir: replCtx.config.outputDir,
+        hasSearchKey: !!replCtx.config.tavilyApiKey
+      });
+      return;
+    }
+    const currentConfig = await loadConfig();
+    sendJSON(res, {
+      provider: currentConfig.modelConfig.provider,
+      model: currentConfig.modelConfig.model,
+      outputDir: currentConfig.outputDir,
+      hasSearchKey: !!currentConfig.tavilyApiKey
+    });
+    return;
+  }
+  if (pathname === "/api/tools" && method === "GET") {
+    const tools = await createToolRegistry(config);
+    const toolList = tools.map((t) => ({
+      name: t.definition.name,
+      description: t.definition.description
+    }));
+    sendJSON(res, { tools: toolList });
+    return;
+  }
+  if (pathname === "/api/team/local-token" && method === "GET") {
+    try {
+      const { loadLocalToken } = await import("./auth-DNQWYQKT.js");
+      const token = await loadLocalToken();
+      sendJSON(res, token || { available: false });
+    } catch {
+      sendJSON(res, { available: false });
+    }
+    return;
+  }
+  if (pathname === "/api/git/status" && method === "GET") {
+    if (!isGitRepo()) {
+      sendJSON(res, { available: false });
+      return;
+    }
+    try {
+      const status = gitStatus();
+      const branch = gitBranch();
+      const log = gitLog(5);
+      const head = gitHeadShort();
+      const uncommitted = hasUncommittedChanges();
+      const summary = gitStatusSummary();
+      sendJSON(res, {
+        available: true,
+        branch,
+        head,
+        uncommitted,
+        summary,
+        status,
+        recentCommits: log
+      });
+    } catch (err) {
+      sendJSON(res, { available: false, error: String(err) });
+    }
+    return;
+  }
+  const costMatch = pathname.match(/^\/api\/cost\/([^/]+)$/);
+  if (costMatch && method === "GET") {
+    try {
+      const messages = await loadSession(costMatch[1]);
+      let totalChars = 0;
+      messages.forEach((m) => {
+        totalChars += (m.content || "").length;
+      });
+      const roughInputTokens = Math.floor(totalChars / 4);
+      const roughOutputTokens = Math.floor(
+        messages.filter((m) => m.role === "assistant").reduce((sum, m) => sum + (m.content || "").length, 0) / 4
+      );
+      const cost = estimateCost(config.modelConfig.model, roughInputTokens, roughOutputTokens);
+      sendJSON(res, {
+        sessionId: costMatch[1],
+        estimatedTokens: { input: roughInputTokens, output: roughOutputTokens },
+        cost: cost ? { usd: cost.usd, cny: cost.cny, formatted: formatCost(cost) } : null,
+        model: config.modelConfig.model
+      });
+    } catch {
+      sendError(res, "Session not found", 404);
+    }
+    return;
+  }
+  if (pathname === "/api/hooks" && method === "GET") {
+    await hookManager.load();
+    const hooksByEvent = hookManager.listByEvent();
+    sendJSON(res, {
+      total: hookManager.count,
+      byEvent: hooksByEvent
+    });
+    return;
+  }
+  if (pathname === "/api/lines" && method === "GET") {
+    try {
+      const lines = await listLines(HYPERCORE_DIR2);
+      sendJSON(res, { lines });
+    } catch {
+      sendJSON(res, { lines: [] });
+    }
+    return;
+  }
+  if (pathname === "/api/history" && method === "GET") {
+    try {
+      const outputDir = config.outputDir;
+      const files = await readdir(outputDir);
+      const runs = [];
+      for (const file of files.filter((f) => f.endsWith(".run.json")).reverse().slice(0, 50)) {
+        try {
+          const content = await readFile(join(outputDir, file), "utf-8");
+          const meta = JSON.parse(content);
+          runs.push({
+            file: file.replace(".run.json", ""),
+            lineName: meta.lineName,
+            startTime: meta.startTime,
+            endTime: meta.endTime,
+            model: meta.model,
+            totalTokens: meta.totalTokens,
+            stationCount: meta.stations?.length || 0
+          });
+        } catch {
+        }
+      }
+      sendJSON(res, { runs });
+    } catch {
+      sendJSON(res, { runs: [] });
+    }
+    return;
+  }
+  const historyMatch = pathname.match(/^\/api\/history\/([^/]+)$/);
+  if (historyMatch && method === "GET") {
+    try {
+      const filePath = join(config.outputDir, `${historyMatch[1]}.run.json`);
+      const content = await readFile(filePath, "utf-8");
+      sendJSON(res, JSON.parse(content));
+    } catch {
+      sendError(res, "Run history not found", 404);
+    }
+    return;
+  }
+  if (pathname === "/api/memory" && method === "GET") {
+    try {
+      const { getMemoryStats, listMemories } = await import("./store-Y4LU5QTO.js");
+      const layers = {};
+      for (const layer of ["personal", "project"]) {
+        try {
+          const stats = await getMemoryStats(layer);
+          layers[layer] = { count: stats.total, categories: stats.byCategory };
+        } catch {
+          layers[layer] = { count: 0 };
+        }
+      }
+      let records = [];
+      try {
+        const personal = await listMemories("personal");
+        records = personal.slice(0, 50);
+      } catch {
+      }
+      sendJSON(res, { layers, records });
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/memory/search" && method === "POST") {
+    try {
+      const { parseBody: parseBody2 } = await import("./server-PORT7OEG.js");
+      const body = await parseBody2(req);
+      const query = body.query;
+      if (!query) {
+        sendError(res, "query is required", 400);
+        return;
+      }
+      const { searchMemories } = await import("./store-Y4LU5QTO.js");
+      const results = await searchMemories("personal", query, {
+        category: body.category,
+        limit: 20
+      });
+      sendJSON(res, { results });
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/files" && method === "GET") {
+    try {
+      const url = new URL(req.url || "/", `http://localhost`);
+      const dirPath = url.searchParams.get("path") || ".";
+      const cwd = process.cwd();
+      const absPath = resolve(cwd, dirPath);
+      const rel = relative(cwd, absPath);
+      if (rel.startsWith("..") || isAbsolute(rel)) {
+        sendError(res, "Path outside working directory", 403);
+        return;
+      }
+      const entries = await readdir(absPath, { withFileTypes: true });
+      const items = [];
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") && entry.name !== ".hypercore") continue;
+        try {
+          const fullPath = join(absPath, entry.name);
+          const s = await stat(fullPath);
+          items.push({
+            name: entry.name,
+            type: entry.isDirectory() ? "directory" : "file",
+            size: entry.isFile() ? s.size : void 0
+          });
+        } catch {
+        }
+      }
+      items.sort((a, b) => {
+        if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+      sendJSON(res, { path: relative(cwd, absPath) || ".", entries: items });
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/files/read" && method === "GET") {
+    try {
+      const url = new URL(req.url || "/", `http://localhost`);
+      const filePath = url.searchParams.get("path") || "";
+      if (!filePath) {
+        sendError(res, "path is required", 400);
+        return;
+      }
+      const cwd = process.cwd();
+      const absPath = resolve(cwd, filePath);
+      const rel = relative(cwd, absPath);
+      if (rel.startsWith("..") || isAbsolute(rel)) {
+        sendError(res, "Path outside working directory", 403);
+        return;
+      }
+      const s = await stat(absPath);
+      if (s.size > 102400) {
+        sendError(res, "File too large (>100KB)", 413);
+        return;
+      }
+      const content = await readFile(absPath, "utf-8");
+      sendJSON(res, { path: filePath, content, size: s.size });
+    } catch {
+      sendError(res, "File not found", 404);
+    }
+    return;
+  }
+  if (pathname === "/api/instances" && method === "GET") {
+    try {
+      const { listInstances } = await import("./instance-registry-YSIJXSO7.js");
+      const instances = await listInstances();
+      const currentPid = process.pid;
+      sendJSON(res, {
+        instances: instances.map((inst) => ({
+          ...inst,
+          isCurrent: inst.pid === currentPid
+        })),
+        total: instances.length
+      });
+    } catch {
+      sendJSON(res, { instances: [], total: 0 });
+    }
+    return;
+  }
+  if (pathname === "/api/repl/state" && method === "GET") {
+    const ctx = getREPLContext();
+    if (!ctx) {
+      sendJSON(res, { active: false });
+      return;
+    }
+    sendJSON(res, {
+      active: true,
+      sessionId: ctx.sessionId,
+      model: ctx.config.modelConfig.model,
+      provider: ctx.config.modelConfig.provider,
+      tokens: ctx.sessionTokens,
+      toolCount: ctx.tools.length,
+      chatHistoryLength: ctx.chatHistory.length,
+      cwd: process.cwd()
+    });
+    return;
+  }
+  if (pathname === "/api/repl/commands" && method === "GET") {
+    const ctx = getREPLContext();
+    sendJSON(res, {
+      commands: [
+        { name: "new", description: "\u65B0\u5EFA\u4F1A\u8BDD", category: "session" },
+        { name: "save", description: "\u4FDD\u5B58\u4F1A\u8BDD", category: "session" },
+        { name: "cost", description: "\u67E5\u770B\u8D39\u7528", category: "session" },
+        { name: "compact", description: "\u538B\u7F29\u5386\u53F2", category: "context" },
+        { name: "memory", description: "\u8BB0\u5FC6\u7EDF\u8BA1", category: "memory" },
+        { name: "remember", description: "\u624B\u52A8\u8BB0\u5FC6", category: "memory" },
+        { name: "recall", description: "\u641C\u7D22\u8BB0\u5FC6", category: "memory" }
+      ],
+      replActive: !!ctx
+    });
+    return;
+  }
+  if (pathname === "/api/onboard" && method === "POST") {
+    try {
+      const { parseBody: parseBody2 } = await import("./server-PORT7OEG.js");
+      const body = await parseBody2(req);
+      if (!body.industry || !body.role || !body.provider || !body.apiKey) {
+        sendError(res, "\u7F3A\u5C11\u5FC5\u8981\u5B57\u6BB5\uFF08industry, role, provider, apiKey\uFF09", 400);
+        return;
+      }
+      const existingProfilePath = join(HYPERCORE_DIR, "workspace-profile.json");
+      if (existsSync(existingProfilePath)) {
+        try {
+          const existing = JSON.parse(await readFile(existingProfilePath, "utf-8"));
+          if (existing && existing.id) {
+            sendJSON(res, { success: true, profile: existing, alreadyExists: true });
+            return;
+          }
+        } catch {
+        }
+      }
+      const profile = generateWorkspaceProfile(body);
+      await initializeWorkspace({
+        provider: body.provider,
+        apiKey: body.apiKey,
+        tavilyKey: body.tavilyKey || void 0,
+        role: body.role
+      });
+      const profilePath = join(HYPERCORE_DIR, "workspace-profile.json");
+      await writeFile(profilePath, JSON.stringify(profile, null, 2), "utf-8");
+      sendJSON(res, { success: true, profile });
+    } catch (err) {
+      console.error("[Onboard Error]", err);
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/workspace-profile" && method === "GET") {
+    try {
+      const profilePath = join(HYPERCORE_DIR, "workspace-profile.json");
+      if (!existsSync(profilePath)) {
+        sendJSON(res, { profile: null });
+        return;
+      }
+      const content = await readFile(profilePath, "utf-8");
+      sendJSON(res, { profile: JSON.parse(content) });
+    } catch (err) {
+      console.error("[Profile Error]", err);
+      sendJSON(res, { profile: null });
+    }
+    return;
+  }
+  if (pathname === "/api/admin/status" && method === "GET") {
+    try {
+      const { getStats, listItems } = await import("./backlog-Q2NZCLNY.js");
+      const { getEventsSummary } = await import("./telemetry-6R4EIE6O.js");
+      const { listMilestones } = await import("./roadmap-5OBEKROY.js");
+      const [stats, developing, done, summary7d, milestones] = await Promise.all([
+        getStats(),
+        listItems({ status: "developing" }),
+        listItems({ status: "done" }),
+        getEventsSummary(7).catch(() => null),
+        listMilestones().catch(() => [])
+      ]);
+      sendJSON(res, {
+        backlog: stats,
+        developing: developing.slice(0, 5).map((i) => ({ id: i.id, title: i.title, priority: i.priority, wuxing: i.wuxing })),
+        recentDone: done.slice(0, 5).map((i) => ({ id: i.id, title: i.title, resolvedAt: i.resolvedAt })),
+        telemetry: summary7d ? {
+          totalEvents: summary7d.totalEvents,
+          avgSessionRounds: summary7d.avgSessionRounds,
+          topErrors: summary7d.errors.slice(0, 3)
+        } : null,
+        milestones: milestones.filter((m) => m.status !== "cancelled").slice(0, 5).map((m) => ({
+          version: m.version,
+          name: m.name,
+          status: m.status
+        }))
+      });
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/admin/backlog" && method === "GET") {
+    try {
+      const { listItems, getStats } = await import("./backlog-Q2NZCLNY.js");
+      const url = new URL(req.url || "/", "http://localhost");
+      const filters = {};
+      for (const key of ["status", "wuxing", "priority", "type"]) {
+        const val = url.searchParams.get(key);
+        if (val) filters[key] = val;
+      }
+      const [items, stats] = await Promise.all([
+        listItems(filters),
+        getStats()
+      ]);
+      sendJSON(res, { items, stats });
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/admin/quality" && method === "GET") {
+    try {
+      const { runQualityReport } = await import("./quality-ST7PPNFR.js");
+      const report = await runQualityReport(process.cwd(), { skipTests: true, skipBuild: true });
+      sendJSON(res, report);
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/admin/diagnose" && method === "GET") {
+    try {
+      const { runRuleDiagnosis } = await import("./diagnose-AFW3ZTZ4.js");
+      const url = new URL(req.url || "/", "http://localhost");
+      const days = parseInt(url.searchParams.get("days") || "7") || 7;
+      const findings = await runRuleDiagnosis(days);
+      sendJSON(res, { findings, total: findings.length });
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/admin/verify" && method === "GET") {
+    try {
+      const { verifyCompletedItems } = await import("./verify-JUDKTPKZ.js");
+      const report = await verifyCompletedItems();
+      sendJSON(res, report);
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/admin/roadmap" && method === "GET") {
+    try {
+      const { getRoadmap } = await import("./roadmap-5OBEKROY.js");
+      const versions = await getRoadmap();
+      sendJSON(res, { versions });
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/admin/telemetry" && method === "GET") {
+    try {
+      const { getEventsSummary } = await import("./telemetry-6R4EIE6O.js");
+      const url = new URL(req.url || "/", "http://localhost");
+      const days = parseInt(url.searchParams.get("days") || "7") || 7;
+      const summary = await getEventsSummary(days);
+      sendJSON(res, summary);
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  if (pathname === "/api/admin/tests" && method === "GET") {
+    try {
+      const { getTestRunnerSnapshot } = await import("./test-runner-ZQH5Y6OJ.js");
+      const snapshot = await getTestRunnerSnapshot({
+        projectRoot: process.cwd(),
+        baseUrl: `http://127.0.0.1:${getActivePort()}`
+      });
+      sendJSON(res, snapshot);
+    } catch (err) {
+      sendAdminTestError(res, err);
+    }
+    return;
+  }
+  if (pathname === "/api/admin/tests/auto" && method === "GET") {
+    try {
+      const { getAutoRegressionSnapshot } = await import("./test-runner-ZQH5Y6OJ.js");
+      const snapshot = await getAutoRegressionSnapshot({
+        projectRoot: process.cwd(),
+        baseUrl: `http://127.0.0.1:${getActivePort()}`
+      });
+      sendJSON(res, snapshot);
+    } catch (err) {
+      sendAdminTestError(res, err, "\u67E5\u8BE2\u81EA\u52A8\u56DE\u5F52\u914D\u7F6E\u5931\u8D25");
+    }
+    return;
+  }
+  if (pathname === "/api/admin/tests/auto" && method === "POST") {
+    try {
+      const { parseBody: parseBody2 } = await import("./server-PORT7OEG.js");
+      const body = await parseBody2(req);
+      const update = {};
+      if (Object.prototype.hasOwnProperty.call(body, "enabled")) {
+        if (typeof body.enabled !== "boolean") {
+          sendError(res, "enabled must be boolean", 400);
+          return;
+        }
+        update.enabled = body.enabled;
+      }
+      if (Object.prototype.hasOwnProperty.call(body, "suiteId")) {
+        if (typeof body.suiteId !== "string") {
+          sendError(res, "suiteId must be string", 400);
+          return;
+        }
+        update.suiteId = body.suiteId;
+      }
+      if (Object.prototype.hasOwnProperty.call(body, "intervalMinutes")) {
+        const intervalRaw = body.intervalMinutes;
+        const interval = typeof intervalRaw === "number" ? intervalRaw : Number(intervalRaw);
+        if (!Number.isFinite(interval)) {
+          sendError(res, "intervalMinutes must be number", 400);
+          return;
+        }
+        update.intervalMinutes = Math.floor(interval);
+      }
+      const { updateAutoRegressionConfig, getTestRunnerSnapshot } = await import("./test-runner-ZQH5Y6OJ.js");
+      await updateAutoRegressionConfig(update, {
+        projectRoot: process.cwd(),
+        baseUrl: `http://127.0.0.1:${getActivePort()}`
+      });
+      const snapshot = await getTestRunnerSnapshot({
+        projectRoot: process.cwd(),
+        baseUrl: `http://127.0.0.1:${getActivePort()}`
+      });
+      sendJSON(res, snapshot);
+    } catch (err) {
+      sendAdminTestError(res, err, "\u81EA\u52A8\u56DE\u5F52\u914D\u7F6E\u66F4\u65B0\u5931\u8D25");
+    }
+    return;
+  }
+  const testRunDownloadMatch = pathname.match(/^\/api\/admin\/tests\/runs\/([^/]+)\/download$/);
+  if (testRunDownloadMatch && method === "GET") {
+    try {
+      const runId = decodeURIComponent(testRunDownloadMatch[1]);
+      const {
+        getTestRunDetail,
+        formatTestRunDownloadText,
+        getTestRunDownloadFileName
+      } = await import("./test-runner-ZQH5Y6OJ.js");
+      const detail = await getTestRunDetail(runId);
+      const filename = getTestRunDownloadFileName(detail.info, "log");
+      const content = formatTestRunDownloadText(detail);
+      sendAttachment(res, content, filename, "text/plain; charset=utf-8");
+    } catch (err) {
+      sendAdminTestError(res, err, "\u4E0B\u8F7D\u6D4B\u8BD5\u65E5\u5FD7\u5931\u8D25");
+    }
+    return;
+  }
+  const testRunExportMatch = pathname.match(/^\/api\/admin\/tests\/runs\/([^/]+)\/export$/);
+  if (testRunExportMatch && method === "GET") {
+    try {
+      const runId = decodeURIComponent(testRunExportMatch[1]);
+      const { getTestRunDetail, getTestRunDownloadFileName } = await import("./test-runner-ZQH5Y6OJ.js");
+      const detail = await getTestRunDetail(runId);
+      const filename = getTestRunDownloadFileName(detail.info, "json");
+      const content = JSON.stringify(detail, null, 2);
+      sendAttachment(res, content, filename, "application/json; charset=utf-8");
+    } catch (err) {
+      sendAdminTestError(res, err, "\u5BFC\u51FA\u6D4B\u8BD5\u8BE6\u60C5\u5931\u8D25");
+    }
+    return;
+  }
+  const testRunDetailMatch = pathname.match(/^\/api\/admin\/tests\/runs\/([^/]+)$/);
+  if (testRunDetailMatch && method === "GET") {
+    try {
+      const runId = decodeURIComponent(testRunDetailMatch[1]);
+      const { getTestRunDetail } = await import("./test-runner-ZQH5Y6OJ.js");
+      const detail = await getTestRunDetail(runId);
+      sendJSON(res, detail);
+    } catch (err) {
+      sendAdminTestError(res, err, "\u67E5\u8BE2\u6D4B\u8BD5\u8BE6\u60C5\u5931\u8D25");
+    }
+    return;
+  }
+  if (pathname === "/api/admin/tests/run" && method === "POST") {
+    try {
+      const { parseBody: parseBody2 } = await import("./server-PORT7OEG.js");
+      const body = await parseBody2(req);
+      const suiteId = typeof body.suiteId === "string" && body.suiteId.trim() ? body.suiteId.trim() : void 0;
+      const { startTestSuiteRun } = await import("./test-runner-ZQH5Y6OJ.js");
+      const snapshot = await startTestSuiteRun({
+        projectRoot: process.cwd(),
+        suiteId,
+        baseUrl: `http://127.0.0.1:${getActivePort()}`
+      });
+      sendJSON(res, snapshot, 202);
+    } catch (err) {
+      sendAdminTestError(res, err, "\u6D4B\u8BD5\u542F\u52A8\u5931\u8D25");
+    }
+    return;
+  }
+  sendError(res, `Not Found: ${pathname}`, 404);
+}
+
+// src/web/sse.ts
+function sseWrite(res, type, data) {
+  res.write(`data: ${JSON.stringify({ type, ...typeof data === "object" && data !== null ? data : { content: data } })}
+
+`);
+}
+function buildSystemPrompt() {
+  return `You are Hypercore AI Assistant, running through the Web Dashboard.
+You have access to tools for file operations, search, and web fetching.
+Be concise, helpful, and use markdown formatting in your responses.
+Current time: ${(/* @__PURE__ */ new Date()).toLocaleString()}`;
+}
+async function loadEffectiveConfig(fallbackConfig) {
+  const replContext2 = getREPLContext();
+  if (replContext2) {
+    return replContext2.config;
+  }
+  try {
+    return await loadConfig();
+  } catch {
+    return fallbackConfig;
+  }
+}
+async function handleChatSSE(req, res, config) {
+  let body;
+  try {
+    body = await parseBody(req);
+  } catch {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Invalid request body" }));
+    return;
+  }
+  const message = body.message;
+  const sessionId = body.sessionId || generateSessionId();
+  if (!message) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Message is required" }));
+    return;
+  }
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    "Access-Control-Allow-Origin": `http://localhost:${getActivePort()}`,
+    "X-Accel-Buffering": "no"
+  });
+  sseWrite(res, "session", { sessionId });
+  try {
+    let history = [];
+    try {
+      history = await loadSession(sessionId);
+    } catch {
+    }
+    const effectiveConfig = await loadEffectiveConfig(config);
+    const { modelConfig } = effectiveConfig;
+    const tools = await createToolRegistry(effectiveConfig);
+    const systemPrompt = buildSystemPrompt();
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    if (modelConfig.sdkType === "anthropic") {
+      const client = createLLMClient(modelConfig);
+      const result = await streamCallLLM(client, {
+        systemPrompt,
+        userPrompt: message,
+        tools,
+        model: modelConfig.model,
+        history,
+        onText: (text) => {
+          sseWrite(res, "text", { content: text });
+        },
+        onToolCall: (name, input) => {
+          sseWrite(res, "tool_call", { name, input });
+        }
+      });
+      totalInputTokens = result.tokenUsage.inputTokens;
+      totalOutputTokens = result.tokenUsage.outputTokens;
+      for (const tc of result.toolCalls) {
+        sseWrite(res, "tool_result", {
+          name: tc.toolName,
+          output: tc.output.substring(0, 2e3)
+          // Truncate for SSE
+        });
+      }
+      history.push({ role: "user", content: message });
+      history.push({ role: "assistant", content: result.responseText || result.output });
+      await saveSession(sessionId, history);
+    } else {
+      const client = createOpenAIClient(modelConfig);
+      const openaiMessages = history.map((m) => ({
+        role: m.role,
+        content: m.content
+      }));
+      openaiMessages.push({ role: "user", content: message });
+      const result = await streamOpenAIChat(client, openaiMessages, {
+        model: modelConfig.model,
+        tools,
+        onChunk: (text) => {
+          sseWrite(res, "text", { content: text });
+        },
+        onToolCall: (name) => {
+          sseWrite(res, "tool_call", { name, input: {} });
+        }
+      });
+      totalInputTokens = result.tokenUsage.inputTokens;
+      totalOutputTokens = result.tokenUsage.outputTokens;
+      history.push({ role: "user", content: message });
+      history.push({ role: "assistant", content: result.responseContent || result.content });
+      await saveSession(sessionId, history);
+    }
+    const cost = estimateCost(modelConfig.model, totalInputTokens, totalOutputTokens);
+    sseWrite(res, "done", {
+      tokenUsage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
+      cost: cost ? { usd: cost.usd, cny: cost.cny } : null,
+      model: modelConfig.model,
+      sessionId
+    });
+  } catch (err) {
+    sseWrite(res, "error", { content: String(err) });
+  }
+  res.end();
+}
+async function handleRunSSE(req, res, config) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    "Access-Control-Allow-Origin": `http://localhost:${getActivePort()}`
+  });
+  try {
+    const body = await parseBody(req);
+    const lineName = body.lineName;
+    const userInputs = body.inputs || {};
+    if (!lineName) {
+      sseWrite(res, "error", { content: "\u7F3A\u5C11 lineName \u53C2\u6570" });
+      res.end();
+      return;
+    }
+    const effectiveRunConfig = await loadEffectiveConfig(config);
+    const client = effectiveRunConfig.modelConfig.sdkType === "openai" ? createOpenAIClient(effectiveRunConfig.modelConfig) : createLLMClient(effectiveRunConfig.modelConfig);
+    const engine = new Engine(client, effectiveRunConfig, HYPERCORE_DIR2);
+    sseWrite(res, "run_start", { lineName, inputs: userInputs });
+    const result = await engine.run(lineName, userInputs, {
+      onStationStart: (index, total, name, agentName) => {
+        sseWrite(res, "station_start", { index, total, name, agentName });
+      },
+      onStationText: (text) => {
+        sseWrite(res, "text", { content: text });
+      },
+      onToolCall: (name, input) => {
+        sseWrite(res, "tool_call", { name, input });
+      },
+      onStationComplete: (index, name) => {
+        sseWrite(res, "station_complete", { index, name });
+      },
+      onStationSkipped: (index, name, reason) => {
+        sseWrite(res, "station_skipped", { index, name, reason });
+      },
+      onStationRetry: (index, name, attempt, maxRetry, error) => {
+        sseWrite(res, "station_retry", { index, name, attempt, maxRetry, error });
+      },
+      onCheckpoint: async (type, output, description) => {
+        sseWrite(res, "checkpoint", { type, output: output.slice(0, 2e3), description });
+        return { action: "approve" };
+      },
+      onComplete: (runResult) => {
+        const cost = estimateCost(
+          effectiveRunConfig.modelConfig.model,
+          runResult.totalTokens.inputTokens,
+          runResult.totalTokens.outputTokens
+        );
+        sseWrite(res, "run_complete", {
+          lineName: runResult.lineName,
+          outputPath: runResult.outputPath,
+          totalTokens: runResult.totalTokens,
+          cost: cost ? { usd: cost.usd, cny: cost.cny } : null,
+          duration: runResult.endTime.getTime() - runResult.startTime.getTime(),
+          stationCount: runResult.stationResults.length
+        });
+      }
+    });
+  } catch (err) {
+    sseWrite(res, "error", { content: String(err) });
+  }
+  res.end();
+}
+
+// src/team/api.ts
+function sendJSON2(res, data, status = 200) {
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "http://localhost:3210",
+    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization"
+  });
+  res.end(JSON.stringify(data));
+}
+function sendError2(res, message, status = 400) {
+  sendJSON2(res, { error: message }, status);
+}
+var MAX_BODY_SIZE = 1024 * 1024;
+async function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let totalSize = 0;
+    req.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize > MAX_BODY_SIZE) {
+        req.destroy();
+        reject(new Error("Request body too large (>1MB)"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        const body = Buffer.concat(chunks).toString("utf-8");
+        resolve2(body ? JSON.parse(body) : {});
+      } catch {
+        resolve2({});
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function getToken(req) {
+  const auth = req.headers["authorization"];
+  if (!auth || !auth.startsWith("Bearer ")) return null;
+  return auth.slice(7);
+}
+async function handleTeamApiRequest(req, res, _config, pathname) {
+  const method = req.method || "GET";
+  if (method === "OPTIONS") {
+    res.writeHead(204, {
+      "Access-Control-Allow-Origin": "http://localhost:3210",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization"
+    });
+    res.end();
+    return;
+  }
+  if (pathname === "/api/team/create" && method === "POST") {
+    const body = await readBody(req);
+    const name = String(body.name || "").trim();
+    const ownerName = String(body.ownerName || "").trim();
+    if (!name || !ownerName) {
+      sendError2(res, "\u56E2\u961F\u540D\u79F0\u548C\u521B\u5EFA\u8005\u540D\u79F0\u5FC5\u586B");
+      return;
+    }
+    const { team: team2, ownerToken } = await createTeam(name, ownerName);
+    sendJSON2(res, { team: team2, ownerToken }, 201);
+    return;
+  }
+  if (pathname === "/api/team/join" && method === "POST") {
+    const body = await readBody(req);
+    const joinCode = String(body.joinCode || "").trim();
+    const memberName = String(body.memberName || "").trim();
+    if (!joinCode || !memberName) {
+      sendError2(res, "\u52A0\u5165\u7801\u548C\u6210\u5458\u540D\u79F0\u5FC5\u586B");
+      return;
+    }
+    const team2 = await findTeamByJoinCode(joinCode);
+    if (!team2) {
+      sendError2(res, "\u65E0\u6548\u7684\u52A0\u5165\u7801", 404);
+      return;
+    }
+    const result = await addMember(team2.id, memberName);
+    if (!result) {
+      sendError2(res, "\u65E0\u6CD5\u52A0\u5165\u56E2\u961F");
+      return;
+    }
+    sendJSON2(res, {
+      team: result.team,
+      member: result.member,
+      token: result.member.token
+    }, 201);
+    return;
+  }
+  const teamMatch = pathname.match(/^\/api\/team\/([^/]+)(?:\/(.+))?$/);
+  if (!teamMatch) {
+    sendError2(res, "\u672A\u77E5\u8DEF\u7531", 404);
+    return;
+  }
+  const teamId = teamMatch[1];
+  const subpath = teamMatch[2] || "";
+  const team = await loadTeam(teamId);
+  if (!team) {
+    sendError2(res, "\u56E2\u961F\u4E0D\u5B58\u5728", 404);
+    return;
+  }
+  const token = getToken(req);
+  if (!token) {
+    sendError2(res, "\u672A\u63D0\u4F9B\u8BA4\u8BC1\u4EE4\u724C", 401);
+    return;
+  }
+  const member = validateToken(team, token);
+  if (!member) {
+    sendError2(res, "\u8BA4\u8BC1\u5931\u8D25", 401);
+    return;
+  }
+  if (subpath === "status" && method === "GET") {
+    sendJSON2(res, {
+      team: { id: team.id, name: team.name, joinCode: team.joinCode },
+      members: team.members.map((m) => ({
+        id: m.id,
+        name: m.name,
+        role: m.role,
+        status: m.status,
+        lastSeen: m.lastSeen
+      }))
+    });
+    return;
+  }
+  if (subpath === "tasks" && method === "GET") {
+    const tasks = await listTasks(teamId);
+    sendJSON2(res, { tasks });
+    return;
+  }
+  if (subpath === "tasks" && method === "POST") {
+    const body = await readBody(req);
+    const title = String(body.title || "").trim();
+    if (!title) {
+      sendError2(res, "\u4EFB\u52A1\u6807\u9898\u5FC5\u586B");
+      return;
+    }
+    const task = await addTask(teamId, {
+      title,
+      description: body.description ? String(body.description) : void 0,
+      assignee: body.assignee ? String(body.assignee) : void 0,
+      status: body.status || "todo",
+      priority: body.priority || "B",
+      createdBy: member.id
+    });
+    sendJSON2(res, { task }, 201);
+    return;
+  }
+  const taskMatch = subpath.match(/^tasks\/(\d+)$/);
+  if (taskMatch) {
+    const taskId = taskMatch[1];
+    if (method === "PUT") {
+      const body = await readBody(req);
+      const updated = await updateTask(teamId, taskId, body);
+      if (!updated) {
+        sendError2(res, "\u4EFB\u52A1\u4E0D\u5B58\u5728", 404);
+        return;
+      }
+      sendJSON2(res, { task: updated });
+      return;
+    }
+    if (method === "DELETE") {
+      const ok = await deleteTask(teamId, taskId);
+      if (!ok) {
+        sendError2(res, "\u4EFB\u52A1\u4E0D\u5B58\u5728", 404);
+        return;
+      }
+      sendJSON2(res, { success: true });
+      return;
+    }
+  }
+  if (subpath === "runs" && method === "GET") {
+    const runs = await listRuns(teamId);
+    sendJSON2(res, { runs });
+    return;
+  }
+  const runMatch = subpath.match(/^runs\/([^/]+)$/);
+  if (runMatch && method === "GET") {
+    const run = await loadRun(teamId, runMatch[1]);
+    if (!run) {
+      sendError2(res, "\u6267\u884C\u8BB0\u5F55\u4E0D\u5B58\u5728", 404);
+      return;
+    }
+    sendJSON2(res, { run });
+    return;
+  }
+  sendError2(res, "\u672A\u77E5\u8DEF\u7531", 404);
+}
+
+// src/web/server.ts
+var wsRoutes = /* @__PURE__ */ new Map();
+function registerWSRoute(pathname, wss) {
+  wsRoutes.set(pathname, wss);
+}
+function parseHostnameFromHostHeader(hostHeader) {
+  const normalized = hostHeader.trim();
+  if (!normalized) return "";
+  if (normalized.startsWith("[")) {
+    const end = normalized.indexOf("]");
+    if (end > 1) return normalized.slice(1, end);
+    return normalized;
+  }
+  const firstColon = normalized.indexOf(":");
+  const lastColon = normalized.lastIndexOf(":");
+  if (firstColon >= 0 && firstColon === lastColon) {
+    return normalized.slice(0, firstColon);
+  }
+  return normalized;
+}
+function isLocalHostname(hostname) {
+  const normalized = hostname.trim().toLowerCase();
+  return ["localhost", "127.0.0.1", "::1"].includes(normalized);
+}
+function isLanTeamMode(host) {
+  return host === "0.0.0.0" || host === "::";
+}
+function isLanAllowedApiPath(pathname) {
+  if (pathname === "/api/team/create" || pathname === "/api/team/join") return true;
+  if (pathname === "/api/team/local-token") return false;
+  if (/^\/api\/team\/[^/]+\/.+$/.test(pathname)) return true;
+  if (/^\/api\/network\/[^/]+(?:\/.*)?$/.test(pathname)) return true;
+  return false;
+}
+function canAccessApiPath(pathname, localRequest, lanTeamMode) {
+  if (localRequest) return true;
+  if (lanTeamMode && isLanAllowedApiPath(pathname)) return true;
+  return false;
+}
+function canAccessWebSocketPath(pathname, localRequest, lanTeamMode) {
+  if (localRequest) return true;
+  if (lanTeamMode && pathname === "/ws/team") return true;
+  return false;
+}
+function resolveBrowserHost(host) {
+  if (host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  if (host.includes(":") && !host.startsWith("[")) return `[${host}]`;
+  return host;
+}
+function installUpgradeRouter(server, host) {
+  const lanTeamMode = isLanTeamMode(host);
+  server.on("upgrade", (req, socket, head) => {
+    const pathname = new URL(req.url || "/", "http://localhost").pathname;
+    const localRequest = isLocalRequest(req);
+    if (!canAccessWebSocketPath(pathname, localRequest, lanTeamMode)) {
+      socket.destroy();
+      return;
+    }
+    const wss = wsRoutes.get(pathname);
+    if (wss) {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    } else {
+      console.error(`  \x1B[33m[WS Router]\x1B[0m No handler for: ${pathname} (registered: ${[...wsRoutes.keys()].join(", ")})`);
+      socket.destroy();
+    }
+  });
+}
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function resolveStaticDir() {
+  const candidates = [
+    // 1. Dev mode: tsx runs from src/web/server.ts → __dirname = src/web/
+    path.join(__dirname, "static"),
+    // 2. Built mode: tsup bundles to dist/ → __dirname = dist/
+    path.join(__dirname, "web", "static"),
+    // 3. Built mode alt: chunk may be in dist/ subfolder
+    path.join(__dirname, "..", "web", "static"),
+    // 4. CWD is project root (dev)
+    path.join(process.cwd(), "src", "web", "static"),
+    // 5. CWD is project root (built)
+    path.join(process.cwd(), "dist", "web", "static")
+  ];
+  for (const dir of candidates) {
+    if (fs.existsSync(path.join(dir, "index.html"))) {
+      return dir;
+    }
+  }
+  return candidates[0];
+}
+var STATIC_DIR = resolveStaticDir();
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+var MAX_BODY_SIZE2 = 1024 * 1024;
+function parseBody(req) {
+  return new Promise((resolve2, reject) => {
+    const contentType = (req.headers["content-type"] || "").toLowerCase();
+    if (contentType && !contentType.includes("application/json")) {
+      reject(new Error("Content-Type must be application/json"));
+      return;
+    }
+    const chunks = [];
+    let totalSize = 0;
+    req.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize > MAX_BODY_SIZE2) {
+        req.destroy();
+        reject(new Error("Request body too large (>1MB)"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        const body = Buffer.concat(chunks).toString("utf-8");
+        resolve2(body ? JSON.parse(body) : {});
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function isLocalRequest(req) {
+  const host = req.headers.host || "";
+  const hostname = parseHostnameFromHostHeader(host);
+  if (!isLocalHostname(hostname)) {
+    return false;
+  }
+  const method = (req.method || "GET").toUpperCase();
+  if (["POST", "PUT", "DELETE", "PATCH"].includes(method)) {
+    const origin = req.headers.origin || "";
+    const referer = req.headers.referer || "";
+    if (origin && !isLocalOrigin(origin)) {
+      return false;
+    }
+    if (!origin && referer && !isLocalOrigin(referer)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isLocalOrigin(urlStr) {
+  try {
+    const u = new URL(urlStr);
+    return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(u.hostname);
+  } catch {
+    return false;
+  }
+}
+var activePort = 3210;
+function getActivePort() {
+  return activePort;
+}
+function setActivePort(p) {
+  activePort = p;
+}
+function sendJSON(res, data, status = 200) {
+  const json = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-cache, no-store, must-revalidate",
+    "Pragma": "no-cache",
+    "Expires": "0",
+    "Access-Control-Allow-Origin": `http://localhost:${activePort}`,
+    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization"
+  });
+  res.end(json);
+}
+function sendError(res, message, status = 500) {
+  sendJSON(res, { error: message }, status);
+}
+function hasWorkspaceProfile() {
+  const profilePath = path.join(HYPERCORE_DIR, "workspace-profile.json");
+  if (!fs.existsSync(profilePath)) return false;
+  try {
+    const content = fs.readFileSync(profilePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return !!(parsed && parsed.id);
+  } catch {
+    return false;
+  }
+}
+function serveStatic(res, urlPath) {
+  let filePath;
+  if (urlPath === "/onboard") {
+    filePath = "/onboard.html";
+  } else if (urlPath === "/" || urlPath === "/workspace") {
+    const replActive = !!getREPLContext();
+    if (replActive) {
+      filePath = "/workspace.html";
+    } else if (hasWorkspaceProfile()) {
+      filePath = "/index.html";
+    } else {
+      res.writeHead(302, { Location: "/onboard" });
+      res.end();
+      return;
+    }
+  } else if (urlPath === "/dashboard") {
+    filePath = "/index.html";
+  } else if (urlPath === "/mirror") {
+    filePath = "/mirror.html";
+  } else {
+    filePath = urlPath;
+  }
+  const fullPath = path.resolve(STATIC_DIR, filePath.replace(/^\//, ""));
+  if (!fullPath.startsWith(STATIC_DIR + path.sep) && fullPath !== STATIC_DIR) {
+    sendError(res, "Forbidden", 403);
+    return;
+  }
+  const ext = path.extname(fullPath);
+  const mimeType = MIME_TYPES[ext] || "application/octet-stream";
+  fs.readFile(fullPath, (err, data) => {
+    if (err) {
+      sendError(res, "Not Found", 404);
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": mimeType,
+      // Prevent browser caching to ensure fresh JS/CSS/HTML on every load
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      "Pragma": "no-cache",
+      "Expires": "0"
+    });
+    res.end(data);
+  });
+}
+function buildWebServer(config, host = "127.0.0.1") {
+  const lanTeamMode = isLanTeamMode(host);
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url || "/", `http://localhost:${activePort}`);
+    const pathname = url.pathname;
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": `http://localhost:${activePort}`,
+        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        "Access-Control-Max-Age": "86400"
+      });
+      res.end();
+      return;
+    }
+    if (pathname.startsWith("/api/") && !canAccessApiPath(pathname, isLocalRequest(req), lanTeamMode)) {
+      sendError(res, "Forbidden: API only accessible from localhost", 403);
+      return;
+    }
+    try {
+      if (pathname === "/api/chat" && req.method === "POST") {
+        await handleChatSSE(req, res, config);
+        return;
+      }
+      if (pathname === "/api/run" && req.method === "POST") {
+        await handleRunSSE(req, res, config);
+        return;
+      }
+      if (pathname.startsWith("/api/network/")) {
+        const { handleNetworkApiRequest } = await import("./api-XGC7D5AW.js");
+        await handleNetworkApiRequest(req, res, config, pathname);
+        return;
+      }
+      if (pathname.startsWith("/api/team/") && pathname !== "/api/team/local-token") {
+        await handleTeamApiRequest(req, res, config, pathname);
+        return;
+      }
+      if (pathname.startsWith("/api/")) {
+        await handleApiRequest(req, res, config, pathname);
+        return;
+      }
+      serveStatic(res, pathname);
+    } catch (err) {
+      console.error("[Server Error]", err);
+      sendError(res, "Internal Server Error", 500);
+    }
+  });
+  installUpgradeRouter(server, host);
+  const teamWss = attachWebSocket(server, config);
+  registerWSRoute("/ws/team", teamWss);
+  const replWss = attachREPLBridge(server);
+  registerWSRoute("/ws/repl", replWss);
+  return server;
+}
+function createWebServer(config, port, host = "127.0.0.1") {
+  const server = buildWebServer(config, host);
+  const browserHost = resolveBrowserHost(host);
+  server.listen(port, host, () => {
+    setActivePort(port);
+    import("./test-runner-ZQH5Y6OJ.js").then(({ getAutoRegressionSnapshot }) => {
+      getAutoRegressionSnapshot({
+        projectRoot: process.cwd(),
+        baseUrl: `http://127.0.0.1:${port}`
+      }).catch(() => {
+      });
+    }).catch(() => {
+    });
+    const replActive = !!getREPLContext();
+    if (!replActive) {
+      const httpUrl = `http://${browserHost}:${port}`;
+      console.log(`
+  \x1B[36mHypercore Dashboard\x1B[0m  \x1B[4m${httpUrl}\x1B[0m`);
+      console.log(`  \x1B[90mPress Ctrl+C to stop\x1B[0m
+`);
+    }
+  });
+  return server;
+}
+function createWebServerAutoPort(config, startPort = 3210, host = "127.0.0.1", maxAttempts = 10, silent = false) {
+  return new Promise((resolve2, reject) => {
+    let attempt = 0;
+    function tryPort(port) {
+      const server = buildWebServer(config, host);
+      const browserHost = resolveBrowserHost(host);
+      const onError = (err) => {
+        if (err.code === "EADDRINUSE") {
+          server.removeListener("error", onError);
+          server.close();
+          attempt++;
+          if (attempt < maxAttempts) {
+            tryPort(port + 1);
+          } else {
+            reject(new Error(`\u7AEF\u53E3 ${startPort}-${startPort + maxAttempts - 1} \u5168\u90E8\u88AB\u5360\u7528`));
+          }
+        } else {
+          reject(err);
+        }
+      };
+      server.on("error", onError);
+      server.listen(port, host, () => {
+        server.removeListener("error", onError);
+        setActivePort(port);
+        import("./telemetry-6R4EIE6O.js").then(({ trackWebStart }) => {
+          trackWebStart(host, port, host === "0.0.0.0" || host === "::");
+        }).catch(() => {
+        });
+        import("./test-runner-ZQH5Y6OJ.js").then(({ getAutoRegressionSnapshot }) => {
+          getAutoRegressionSnapshot({
+            projectRoot: process.cwd(),
+            baseUrl: `http://127.0.0.1:${port}`
+          }).catch(() => {
+          });
+        }).catch(() => {
+        });
+        if (!silent) {
+          const replActive = !!getREPLContext();
+          if (!replActive) {
+            const httpUrl = `http://${browserHost}:${port}`;
+            console.log(`
+  \x1B[36mHypercore Dashboard\x1B[0m  \x1B[4m${httpUrl}\x1B[0m`);
+            console.log(`  \x1B[90mPress Ctrl+C to stop\x1B[0m
+`);
+          }
+        }
+        resolve2({ server, port });
+      });
+    }
+    tryPort(startPort);
+  });
+}
+if (process.argv[1] && process.argv[1].includes("web/server")) {
+  const { loadConfig: loadConfig2 } = await import("./config-4EW42BSF.js");
+  const config = await loadConfig2();
+  const port = parseInt(process.env.PORT || "3210", 10);
+  createWebServer(config, port);
+}
+
+export {
+  isGitRepo,
+  gitBranch,
+  gitStatus,
+  gitStatusSummary,
+  gitDiffStaged,
+  gitDiffStagedStat,
+  gitDiffUnstaged,
+  gitLog,
+  gitDiffFiles,
+  gitDiffRange,
+  gitStageFiles,
+  gitCommit,
+  gitCreateBranch,
+  gitPushUpstream,
+  gitDefaultBranch,
+  gitListBranches,
+  gitSwitchBranch,
+  gitDeleteBranch,
+  gitStash,
+  gitStashPop,
+  gitStashList,
+  gitStashDrop,
+  gitDiffFile,
+  gitWorktreeAdd,
+  gitWorktreeList,
+  gitWorktreeRemove,
+  emitToGUI,
+  registerREPLContext,
+  createMultiplexer,
+  hasGUIClients,
+  registerWSRoute,
+  parseHostnameFromHostHeader,
+  isLocalHostname,
+  isLanTeamMode,
+  isLanAllowedApiPath,
+  canAccessApiPath,
+  canAccessWebSocketPath,
+  resolveBrowserHost,
+  parseBody,
+  isLocalRequest,
+  isLocalOrigin,
+  getActivePort,
+  setActivePort,
+  sendJSON,
+  sendError,
+  buildWebServer,
+  createWebServer,
+  createWebServerAutoPort
+};