@monkey-mini-app/host 0.1.0

package/dist/index.js

@@ -0,0 +1,3603 @@
+import * as fs4 from 'fs';
+import fs4__default, { mkdtempSync, readdirSync, statSync, mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync } from 'fs';
+import os, { tmpdir, homedir } from 'os';
+import * as path8 from 'path';
+import path8__default from 'path';
+import fsp, { rm } from 'fs/promises';
+import * as Diff from 'diff';
+import { transform } from 'sucrase';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import git from 'isomorphic-git';
+import { createServer } from 'http';
+import { createServer as createServer$1 } from 'net';
+import { getRequestListener } from '@hono/node-server';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { createInstance } from 'i18next';
+
+// src/agent-cwd.ts
+
+// src/errors.ts
+var HostError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = new.target.name;
+    this.code = code;
+  }
+};
+var HostConfigError = class extends HostError {
+  constructor(message, options) {
+    super(options?.code ?? "HOST_CONFIG_INVALID", message, options);
+  }
+};
+
+// src/agent-cwd.ts
+var CWD_TYPES = /* @__PURE__ */ new Set(["app", "process", "temp", "custom"]);
+function isAgentCwdType(value) {
+  return typeof value === "string" && CWD_TYPES.has(value);
+}
+function assertEnterableDir(abs, label) {
+  if (!path8__default.isAbsolute(abs)) {
+    throw new HostError("INVALID_AGENT_CWD", `agent: ${label} must be an absolute path: ${abs}`);
+  }
+  try {
+    if (!statSync(abs).isDirectory()) {
+      throw new HostError("INVALID_AGENT_CWD", `agent: ${label} is not a directory: ${abs}`);
+    }
+  } catch (cause) {
+    if (cause instanceof HostError) throw cause;
+    throw new HostError(
+      "INVALID_AGENT_CWD",
+      `agent: ${label} is not an accessible directory: ${abs}`,
+      { cause }
+    );
+  }
+  return abs;
+}
+function resolveAgentCwd(input, ctx = {}) {
+  const rawPath = typeof input.cwd === "string" ? input.cwd.trim() : "";
+  const hasPath = rawPath.length > 0;
+  const type = input.cwdType;
+  if (type !== void 0 && !isAgentCwdType(type)) {
+    throw new HostError(
+      "INVALID_AGENT_CWD",
+      `agent: cwdType must be app|process|temp|custom (got ${JSON.stringify(type)})`
+    );
+  }
+  if (hasPath && type !== void 0 && type !== "custom") {
+    throw new HostError(
+      "INVALID_AGENT_CWD",
+      `agent: cwd path conflicts with cwdType=${type}; omit cwdType or set cwdType:"custom"`
+    );
+  }
+  if (hasPath) {
+    if (!path8__default.isAbsolute(rawPath)) {
+      throw new HostError(
+        "INVALID_AGENT_CWD",
+        `agent: cwd must be an absolute path (got ${JSON.stringify(rawPath)})`
+      );
+    }
+    return assertEnterableDir(rawPath, "cwd");
+  }
+  const effective = type ?? "process";
+  switch (effective) {
+    case "custom":
+      throw new HostError("INVALID_AGENT_CWD", 'agent: cwdType "custom" requires cwd (absolute path)');
+    case "app": {
+      const appDir = typeof ctx.appDir === "string" ? ctx.appDir.trim() : "";
+      if (!appDir) {
+        throw new HostError(
+          "INVALID_AGENT_CWD",
+          'agent: cwdType "app" requires AppCallContext.appDir'
+        );
+      }
+      return assertEnterableDir(path8__default.resolve(appDir), "appDir");
+    }
+    case "process":
+      return assertEnterableDir(path8__default.resolve(process.cwd()), "process.cwd()");
+    case "temp": {
+      const dir = mkdtempSync(path8__default.join(tmpdir(), "mma-agent-"));
+      return assertEnterableDir(dir, "temp");
+    }
+    default: {
+      const _exhaustive = effective;
+      throw new HostError("INVALID_AGENT_CWD", `agent: unhandled cwdType ${_exhaustive}`);
+    }
+  }
+}
+
+// src/app-runtime.ts
+function effectiveSignal(optsSignal, call) {
+  return optsSignal ?? call?.signal;
+}
+function clampMode(theme) {
+  return theme === "dark" ? "dark" : "light";
+}
+function appThemeFile(dir) {
+  return path8__default.join(dir, "theme.json");
+}
+function readAppTheme(dir) {
+  try {
+    const j = JSON.parse(fs4__default.readFileSync(appThemeFile(dir), "utf8"));
+    if (!j.theme) return null;
+    return {
+      theme: clampMode(j.theme),
+      palette: typeof j.palette === "string" ? j.palette : "default"
+    };
+  } catch {
+    return null;
+  }
+}
+function writeAppTheme(dir, val) {
+  if (!val) {
+    try {
+      fs4__default.unlinkSync(appThemeFile(dir));
+    } catch {
+    }
+    return null;
+  }
+  const next = {
+    theme: clampMode(val.theme),
+    palette: typeof val.palette === "string" ? val.palette : "default"
+  };
+  fs4__default.mkdirSync(dir, { recursive: true });
+  fs4__default.writeFileSync(appThemeFile(dir), JSON.stringify(next, null, 2));
+  return next;
+}
+var APP_ID_RE = /^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/;
+function isAppId(value) {
+  return APP_ID_RE.test(value);
+}
+function asAppId(value) {
+  if (!isAppId(value)) {
+    throw new HostError("INVALID_APP_ID", `invalid AppId: ${value}`);
+  }
+  return value;
+}
+function isAbsolutePath(value) {
+  return path8__default.isAbsolute(value);
+}
+function asAbsolutePath(value) {
+  if (!isAbsolutePath(value)) {
+    throw new HostError("INVALID_PATH", `path must be absolute: ${value}`);
+  }
+  return value;
+}
+function assertNever(value, message) {
+  throw new HostError("UNREACHABLE", message ?? `unexpected value: ${String(value)}`);
+}
+
+// src/capabilities.ts
+function missingCap(name) {
+  throw new HostError("CAPABILITY_UNAVAILABLE", `${name}: host capability not available`);
+}
+function bindCapsToContext(ctx, caps) {
+  return {
+    bash: async (command) => caps.bash ? caps.bash(ctx, command) : missingCap("bash"),
+    llm: async (prompt, opts) => caps.llm ? caps.llm(ctx, prompt, opts) : missingCap("llm"),
+    agent: async (goal, opts) => caps.agent ? caps.agent(ctx, goal, opts) : missingCap("agent"),
+    tool: async (name, args) => caps.tool ? caps.tool(ctx, name, args) : missingCap("tool"),
+    mcp: async (name, args) => caps.mcp ? caps.mcp(ctx, name, args) : missingCap("mcp"),
+    credentials: () => caps.credentials ? caps.credentials(ctx) : {},
+    config: () => caps.config ? caps.config(ctx) : {},
+    listTools: () => caps.listTools ? caps.listTools(ctx) : []
+  };
+}
+function joinUnder(root, ...parts) {
+  return asAbsolutePath(path8__default.join(root, ...parts));
+}
+var WorkspacePaths = class _WorkspacePaths {
+  static Rel = {
+    apps: "apps",
+    hostConfig: "host.json",
+    ui: "ui.tsx",
+    api: "main.api.ts",
+    manifest: "manifest.json",
+    storage: "storage",
+    uiCache: ".ui-cache"
+  };
+  root;
+  constructor(root) {
+    this.root = asAbsolutePath(path8__default.resolve(asAbsolutePath(root)));
+  }
+  appsDir() {
+    return joinUnder(this.root, _WorkspacePaths.Rel.apps);
+  }
+  appDir(id) {
+    return joinUnder(this.root, _WorkspacePaths.Rel.apps, asAppId(id));
+  }
+  hostConfigFile() {
+    return joinUnder(this.root, _WorkspacePaths.Rel.hostConfig);
+  }
+  uiCacheDir() {
+    return joinUnder(this.root, _WorkspacePaths.Rel.uiCache);
+  }
+  appFile(id, rel) {
+    const base = this.appDir(id);
+    if (!rel || path8__default.isAbsolute(rel)) {
+      throw new HostError("INVALID_PATH", `unsafe relative path: ${rel}`);
+    }
+    const resolved = path8__default.resolve(base, rel);
+    const prefix = base.endsWith(path8__default.sep) ? base : `${base}${path8__default.sep}`;
+    if (resolved !== base && !resolved.startsWith(prefix)) {
+      throw new HostError("INVALID_PATH", `unsafe relative path: ${rel}`);
+    }
+    return asAbsolutePath(resolved);
+  }
+};
+function detectLineEnding(content) {
+  const crlfIdx = content.indexOf("\r\n");
+  const lfIdx = content.indexOf("\n");
+  if (lfIdx === -1) return "\n";
+  if (crlfIdx === -1) return "\n";
+  return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+function normalizeToLF(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function restoreLineEndings(text, ending) {
+  return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+function normalizeForFuzzyMatch(text) {
+  return text.normalize("NFKC").split("\n").map((line) => line.trimEnd()).join("\n").replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+function splitLinesWithEndings(content) {
+  return content.match(/[^\n]*\n|[^\n]+/g) ?? [];
+}
+function getLineSpans(content) {
+  let offset = 0;
+  return splitLinesWithEndings(content).map((line) => {
+    const span = { start: offset, end: offset + line.length };
+    offset = span.end;
+    return span;
+  });
+}
+function getReplacementLineRange(lines, replacement) {
+  const replacementStart = replacement.matchIndex;
+  const replacementEnd = replacement.matchIndex + replacement.matchLength;
+  let startLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (replacementStart >= line.start && replacementStart < line.end) {
+      startLine = i;
+      break;
+    }
+  }
+  if (startLine === -1) {
+    throw new Error("Replacement range is outside the base content.");
+  }
+  let endLine = startLine;
+  while (endLine < lines.length && lines[endLine].end < replacementEnd) {
+    endLine++;
+  }
+  if (endLine >= lines.length) {
+    throw new Error("Replacement range is outside the base content.");
+  }
+  return { startLine, endLine: endLine + 1 };
+}
+function applyReplacements(content, replacements, offset = 0) {
+  let result = content;
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const replacement = replacements[i];
+    const matchIndex = replacement.matchIndex - offset;
+    result = result.substring(0, matchIndex) + replacement.newText + result.substring(matchIndex + replacement.matchLength);
+  }
+  return result;
+}
+function applyReplacementsPreservingUnchangedLines(originalContent, baseContent, replacements) {
+  const originalLines = splitLinesWithEndings(originalContent);
+  const baseLines = getLineSpans(baseContent);
+  if (originalLines.length !== baseLines.length) {
+    throw new Error("Cannot preserve unchanged lines because the base content has a different line count.");
+  }
+  const groups = [];
+  const sortedReplacements = [...replacements].sort((a, b) => a.matchIndex - b.matchIndex);
+  for (const replacement of sortedReplacements) {
+    const range = getReplacementLineRange(baseLines, replacement);
+    const current = groups[groups.length - 1];
+    if (current && range.startLine < current.endLine) {
+      current.endLine = Math.max(current.endLine, range.endLine);
+      current.replacements.push(replacement);
+      continue;
+    }
+    groups.push({ ...range, replacements: [replacement] });
+  }
+  let originalLineIndex = 0;
+  let result = "";
+  for (const group of groups) {
+    result += originalLines.slice(originalLineIndex, group.startLine).join("");
+    const groupStartOffset = baseLines[group.startLine].start;
+    const groupEndOffset = baseLines[group.endLine - 1].end;
+    result += applyReplacements(
+      baseContent.slice(groupStartOffset, groupEndOffset),
+      group.replacements,
+      groupStartOffset
+    );
+    originalLineIndex = group.endLine;
+  }
+  result += originalLines.slice(originalLineIndex).join("");
+  return result;
+}
+function fuzzyFindText(content, oldText) {
+  const exactIndex = content.indexOf(oldText);
+  if (exactIndex !== -1) {
+    return {
+      found: true,
+      index: exactIndex,
+      matchLength: oldText.length,
+      usedFuzzyMatch: false,
+      contentForReplacement: content
+    };
+  }
+  const fuzzyContent = normalizeForFuzzyMatch(content);
+  const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+  const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+  if (fuzzyIndex === -1) {
+    return {
+      found: false,
+      index: -1,
+      matchLength: 0,
+      usedFuzzyMatch: false,
+      contentForReplacement: content
+    };
+  }
+  return {
+    found: true,
+    index: fuzzyIndex,
+    matchLength: fuzzyOldText.length,
+    usedFuzzyMatch: true,
+    contentForReplacement: fuzzyContent
+  };
+}
+function countOccurrences(content, oldText) {
+  const fuzzyContent = normalizeForFuzzyMatch(content);
+  const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+  return fuzzyContent.split(fuzzyOldText).length - 1;
+}
+function getNotFoundError(path12, editIndex, totalEdits) {
+  if (totalEdits === 1) {
+    return new Error(
+      `Could not find the exact text in ${path12}. The old text must match exactly including all whitespace and newlines.`
+    );
+  }
+  return new Error(
+    `Could not find edits[${editIndex}] in ${path12}. The oldText must match exactly including all whitespace and newlines.`
+  );
+}
+function getDuplicateError(path12, editIndex, totalEdits, occurrences) {
+  if (totalEdits === 1) {
+    return new Error(
+      `Found ${occurrences} occurrences of the text in ${path12}. The text must be unique. Please provide more context to make it unique.`
+    );
+  }
+  return new Error(
+    `Found ${occurrences} occurrences of edits[${editIndex}] in ${path12}. Each oldText must be unique. Please provide more context to make it unique.`
+  );
+}
+function getEmptyOldTextError(path12, editIndex, totalEdits) {
+  if (totalEdits === 1) {
+    return new Error(`oldText must not be empty in ${path12}.`);
+  }
+  return new Error(`edits[${editIndex}].oldText must not be empty in ${path12}.`);
+}
+function getNoChangeError(path12, totalEdits) {
+  if (totalEdits === 1) {
+    return new Error(
+      `No changes made to ${path12}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`
+    );
+  }
+  return new Error(`No changes made to ${path12}. The replacements produced identical content.`);
+}
+function applyEditsToNormalizedContent(normalizedContent, edits, path12) {
+  const normalizedEdits = edits.map((edit) => ({
+    oldText: normalizeToLF(edit.oldText),
+    newText: normalizeToLF(edit.newText)
+  }));
+  for (let i = 0; i < normalizedEdits.length; i++) {
+    if (normalizedEdits[i].oldText.length === 0) {
+      throw getEmptyOldTextError(path12, i, normalizedEdits.length);
+    }
+  }
+  const initialMatches = normalizedEdits.map((edit) => fuzzyFindText(normalizedContent, edit.oldText));
+  const usedFuzzyMatch = initialMatches.some((match) => match.usedFuzzyMatch);
+  const replacementBaseContent = usedFuzzyMatch ? normalizeForFuzzyMatch(normalizedContent) : normalizedContent;
+  const matchedEdits = [];
+  for (let i = 0; i < normalizedEdits.length; i++) {
+    const edit = normalizedEdits[i];
+    const matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);
+    if (!matchResult.found) {
+      throw getNotFoundError(path12, i, normalizedEdits.length);
+    }
+    const occurrences = countOccurrences(replacementBaseContent, edit.oldText);
+    if (occurrences > 1) {
+      throw getDuplicateError(path12, i, normalizedEdits.length, occurrences);
+    }
+    matchedEdits.push({
+      editIndex: i,
+      matchIndex: matchResult.index,
+      matchLength: matchResult.matchLength,
+      newText: edit.newText
+    });
+  }
+  matchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);
+  for (let i = 1; i < matchedEdits.length; i++) {
+    const previous = matchedEdits[i - 1];
+    const current = matchedEdits[i];
+    if (previous.matchIndex + previous.matchLength > current.matchIndex) {
+      throw new Error(
+        `edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${path12}. Merge them into one edit or target disjoint regions.`
+      );
+    }
+  }
+  const baseContent = normalizedContent;
+  const newContent = usedFuzzyMatch ? applyReplacementsPreservingUnchangedLines(normalizedContent, replacementBaseContent, matchedEdits) : applyReplacements(replacementBaseContent, matchedEdits);
+  if (baseContent === newContent) {
+    throw getNoChangeError(path12, normalizedEdits.length);
+  }
+  return { baseContent, newContent };
+}
+function generateDiffString(oldContent, newContent, contextLines = 4) {
+  const parts = Diff.diffLines(oldContent, newContent);
+  const output = [];
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const maxLineNum = Math.max(oldLines.length, newLines.length);
+  const lineNumWidth = String(maxLineNum).length;
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  let lastWasChange = false;
+  let firstChangedLine;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const raw = part.value.split("\n");
+    if (raw[raw.length - 1] === "") {
+      raw.pop();
+    }
+    if (part.added || part.removed) {
+      if (firstChangedLine === void 0) {
+        firstChangedLine = newLineNum;
+      }
+      for (const line of raw) {
+        if (part.added) {
+          const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+          output.push(`+${lineNum} ${line}`);
+          newLineNum++;
+        } else {
+          const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+          output.push(`-${lineNum} ${line}`);
+          oldLineNum++;
+        }
+      }
+      lastWasChange = true;
+    } else {
+      const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+      const hasLeadingChange = lastWasChange;
+      const hasTrailingChange = nextPartIsChange;
+      if (hasLeadingChange && hasTrailingChange) {
+        if (raw.length <= contextLines * 2) {
+          for (const line of raw) {
+            const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+            output.push(` ${lineNum} ${line}`);
+            oldLineNum++;
+            newLineNum++;
+          }
+        } else {
+          const leadingLines = raw.slice(0, contextLines);
+          const trailingLines = raw.slice(raw.length - contextLines);
+          const skippedLines = raw.length - leadingLines.length - trailingLines.length;
+          for (const line of leadingLines) {
+            const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+            output.push(` ${lineNum} ${line}`);
+            oldLineNum++;
+            newLineNum++;
+          }
+          output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+          oldLineNum += skippedLines;
+          newLineNum += skippedLines;
+          for (const line of trailingLines) {
+            const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+            output.push(` ${lineNum} ${line}`);
+            oldLineNum++;
+            newLineNum++;
+          }
+        }
+      } else if (hasLeadingChange) {
+        const shownLines = raw.slice(0, contextLines);
+        const skippedLines = raw.length - shownLines.length;
+        for (const line of shownLines) {
+          const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+          output.push(` ${lineNum} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+        if (skippedLines > 0) {
+          output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+          oldLineNum += skippedLines;
+          newLineNum += skippedLines;
+        }
+      } else if (hasTrailingChange) {
+        const skippedLines = Math.max(0, raw.length - contextLines);
+        if (skippedLines > 0) {
+          output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+          oldLineNum += skippedLines;
+          newLineNum += skippedLines;
+        }
+        for (const line of raw.slice(skippedLines)) {
+          const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+          output.push(` ${lineNum} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+      } else {
+        oldLineNum += raw.length;
+        newLineNum += raw.length;
+      }
+      lastWasChange = false;
+    }
+  }
+  return { diff: output.join("\n"), firstChangedLine };
+}
+
+// src/apps/manifest.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString(raw, key) {
+  const value = raw[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new HostError("INVALID_MANIFEST", `manifest missing ${key}`);
+  }
+  return value;
+}
+function parseManifest(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new HostError("INVALID_MANIFEST", "manifest is not valid JSON", { cause });
+  }
+  if (!isRecord(parsed)) {
+    throw new HostError("INVALID_MANIFEST", "manifest must be an object");
+  }
+  let id;
+  try {
+    id = asAppId(requireString(parsed, "id"));
+  } catch (cause) {
+    throw new HostError("INVALID_MANIFEST", "manifest id is not a valid AppId", { cause });
+  }
+  const permissions = Array.isArray(parsed.permissions) ? parsed.permissions.filter((p) => typeof p === "string") : [];
+  const description = typeof parsed.description === "string" ? parsed.description : void 0;
+  const acronym = typeof parsed.acronym === "string" ? parsed.acronym : void 0;
+  const themeRaw = parsed.theme;
+  const theme = isRecord(themeRaw) && typeof themeRaw.followsHost === "boolean" ? { followsHost: themeRaw.followsHost } : void 0;
+  return {
+    id,
+    name: requireString(parsed, "name"),
+    version: requireString(parsed, "version"),
+    entry: requireString(parsed, "entry"),
+    description,
+    permissions,
+    acronym,
+    theme
+  };
+}
+function acronymOf(name, manifestAcronym) {
+  if (manifestAcronym && /^[a-zA-Z0-9]{2}$/.test(manifestAcronym)) {
+    return manifestAcronym.toUpperCase();
+  }
+  return name.replace(/[^a-zA-Z0-9]/g, "").slice(0, 2).toUpperCase();
+}
+
+// src/apps/app-files.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "storage", ".ui-build", ".ui-cache"]);
+var READ_DEFAULT_MAX_LINES = 2e3;
+function splitLines(text) {
+  if (text.length === 0) return [];
+  const parts = text.split("\n");
+  if (parts.length > 0 && parts[parts.length - 1] === "" && text.endsWith("\n")) {
+    parts.pop();
+  }
+  return parts;
+}
+function formatNumbered(lines, startLine) {
+  const width = String(startLine + lines.length - 1).length;
+  return lines.map((line, i) => `${String(startLine + i).padStart(width, " ")}|${line}`).join("\n");
+}
+function resolveLineWindow(totalLines, range) {
+  if (totalLines === 0) {
+    return { start: 1, end: 0, truncated: false };
+  }
+  let start = range?.startLine;
+  let end = range?.endLine;
+  if (start !== void 0) {
+    if (!Number.isInteger(start) || start < 1) {
+      throw new HostError("INVALID_RANGE", `startLine must be an integer >= 1 (got ${start})`);
+    }
+  }
+  if (end !== void 0) {
+    if (!Number.isInteger(end) || end < 1) {
+      throw new HostError("INVALID_RANGE", `endLine must be an integer >= 1 (got ${end})`);
+    }
+  }
+  if (start === void 0 && end === void 0) {
+    start = 1;
+    end = totalLines;
+  } else if (start === void 0) {
+    start = 1;
+  } else if (end === void 0) {
+    end = totalLines;
+  }
+  if (start > totalLines) {
+    throw new HostError(
+      "INVALID_RANGE",
+      `startLine ${start} is beyond end of file (${totalLines} lines)`
+    );
+  }
+  if (end < start) {
+    throw new HostError(
+      "INVALID_RANGE",
+      `endLine ${end} must be >= startLine ${start}`
+    );
+  }
+  let truncated = false;
+  if (range?.endLine === void 0 && end - start + 1 > READ_DEFAULT_MAX_LINES) {
+    end = start + READ_DEFAULT_MAX_LINES - 1;
+    truncated = true;
+  }
+  if (end > totalLines) end = totalLines;
+  return { start, end, truncated };
+}
+function stripBom(raw) {
+  if (raw.charCodeAt(0) === 65279) {
+    return { bom: "\uFEFF", text: raw.slice(1) };
+  }
+  return { bom: "", text: raw };
+}
+function assertSafeRel(rel) {
+  const cleaned = rel.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!cleaned || cleaned.includes("..") || path8__default.isAbsolute(cleaned) || cleaned.startsWith("/")) {
+    throw new HostError("PATH_ESCAPE", `unsafe relative path: ${rel}`);
+  }
+  return cleaned;
+}
+function walkFiles(dir, base, out) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (SKIP_DIRS.has(name)) continue;
+    const full = path8__default.join(dir, name);
+    let st;
+    try {
+      st = statSync(full);
+    } catch {
+      continue;
+    }
+    const rel = path8__default.relative(base, full).split(path8__default.sep).join("/");
+    if (st.isDirectory()) {
+      walkFiles(full, base, out);
+    } else if (st.isFile()) {
+      out.push({ path: rel, size: st.size });
+    }
+  }
+}
+function listAppFiles(paths, appId) {
+  const id = asAppId(appId);
+  const dir = paths.appDir(id);
+  if (!existsSync(dir)) {
+    throw new HostError("APP_NOT_FOUND", `app not found: ${id}`);
+  }
+  const out = [];
+  walkFiles(dir, dir, out);
+  out.sort((a, b) => a.path.localeCompare(b.path));
+  return out;
+}
+function readAppFile(paths, appId, relPath, range) {
+  const id = asAppId(appId);
+  const rel = assertSafeRel(relPath);
+  const full = paths.appFile(id, rel);
+  if (!existsSync(full)) {
+    throw new HostError("FILE_NOT_FOUND", `file not found: ${rel}`);
+  }
+  const raw = readFileSync(full, "utf8");
+  const { text } = stripBom(raw);
+  const allLines = splitLines(text);
+  const totalLines = allLines.length;
+  const { start, end, truncated } = resolveLineWindow(totalLines, range);
+  const wholeFile = totalLines === 0 || start === 1 && end === totalLines && !truncated && !range?.numbered;
+  let content;
+  if (wholeFile) {
+    content = text;
+  } else if (totalLines === 0) {
+    content = "";
+  } else {
+    const slice = allLines.slice(start - 1, end);
+    content = range?.numbered ? formatNumbered(slice, start) : slice.join("\n");
+  }
+  return {
+    path: rel,
+    content,
+    bytes: Buffer.byteLength(content, "utf8"),
+    totalLines,
+    startLine: totalLines === 0 ? 1 : start,
+    endLine: end,
+    ...truncated ? { truncated: true } : {}
+  };
+}
+function writeAppFile(paths, appId, relPath, content) {
+  const id = asAppId(appId);
+  const rel = assertSafeRel(relPath);
+  if (rel === "manifest.json" || rel.endsWith("/manifest.json")) {
+    parseManifest(content);
+  }
+  const full = paths.appFile(id, rel);
+  const created = !existsSync(full);
+  mkdirSync(path8__default.dirname(full), { recursive: true });
+  writeFileSync(full, content, "utf8");
+  return { path: rel, bytes: Buffer.byteLength(content, "utf8"), created };
+}
+function editAppFile(paths, appId, relPath, edits) {
+  const id = asAppId(appId);
+  const rel = assertSafeRel(relPath);
+  if (!edits.length) {
+    throw new HostError("INVALID_EDIT", "edits must contain at least one replacement");
+  }
+  const full = paths.appFile(id, rel);
+  if (!existsSync(full)) {
+    throw new HostError("FILE_NOT_FOUND", `file not found: ${rel}`);
+  }
+  const raw = readFileSync(full, "utf8");
+  const { bom, text } = stripBom(raw);
+  const ending = detectLineEnding(text);
+  const normalized = normalizeToLF(text);
+  let applied;
+  try {
+    applied = applyEditsToNormalizedContent(normalized, edits, rel);
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw new HostError("EDIT_FAILED", message, { cause });
+  }
+  const restored = restoreLineEndings(applied.newContent, ending);
+  const next = bom + restored;
+  if (rel === "manifest.json" || rel.endsWith("/manifest.json")) {
+    parseManifest(next);
+  }
+  writeFileSync(full, next, "utf8");
+  const { diff } = generateDiffString(applied.baseContent, applied.newContent);
+  return { path: rel, bytes: Buffer.byteLength(next, "utf8"), diff };
+}
+function deleteAppFile(paths, appId, relPath) {
+  const id = asAppId(appId);
+  const rel = assertSafeRel(relPath);
+  if (rel === "manifest.json") {
+    throw new HostError("FORBIDDEN", "cannot delete manifest.json; remove the app instead");
+  }
+  const full = paths.appFile(id, rel);
+  if (!existsSync(full)) {
+    throw new HostError("FILE_NOT_FOUND", `file not found: ${rel}`);
+  }
+  unlinkSync(full);
+  return { path: rel };
+}
+function compileAppSource(src) {
+  const input = src.replace(/^\uFEFF/, "");
+  try {
+    return transform(input, {
+      transforms: ["typescript", "imports"],
+      disableESTransforms: true,
+      filePath: "app.ts"
+    }).code;
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw new HostError("COMPILE_FAILED", `compileAppSource: ${message}`, { cause });
+  }
+}
+
+// src/apps/ctx-http.ts
+var HTTP_DEFAULT_TIMEOUT_MS = 8e3;
+var HTTP_MAX_BYTES = 8 * 1024 * 1024;
+function errText(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function withQuery(url, query) {
+  if (!query) {
+    return url;
+  }
+  const u = new URL(url);
+  for (const [key, value] of Object.entries(query)) {
+    if (value == null) continue;
+    u.searchParams.set(key, String(value));
+  }
+  return u.toString();
+}
+function encodeBody(body, headers) {
+  if (body == null) {
+    return { body: void 0, headers };
+  }
+  if (typeof body === "string") {
+    return { body, headers };
+  }
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  return { body: JSON.stringify(body), headers };
+}
+function headersToObject(h) {
+  const out = {};
+  h.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
+function parseJson(contentType, text) {
+  if (!/json/i.test(contentType)) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function httpRequest(urlOrReq, opts) {
+  const req = typeof urlOrReq === "string" ? { url: urlOrReq, ...opts } : { ...urlOrReq };
+  const rawUrl = req.url.trim();
+  if (!rawUrl) {
+    throw new HostError("HTTP_INVALID_URL", "http: url required");
+  }
+  let url;
+  try {
+    url = new URL(withQuery(rawUrl, req.query));
+  } catch (cause) {
+    throw new HostError("HTTP_INVALID_URL", "http: invalid url", { cause });
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new HostError("HTTP_INVALID_URL", "http: only http/https");
+  }
+  const method = (req.method ?? "GET").toUpperCase();
+  const headers = new Headers(req.headers ?? {});
+  if (!headers.has("user-agent")) {
+    headers.set("user-agent", "monkey-mini-app/0.1");
+  }
+  const encoded = method === "GET" || method === "HEAD" ? { body: void 0, headers } : encodeBody(req.body, headers);
+  const timeout = Number(req.timeout);
+  const ms = Number.isFinite(timeout) && timeout > 0 ? Math.min(timeout, 12e4) : HTTP_DEFAULT_TIMEOUT_MS;
+  const sig = req.signal;
+  if (sig?.aborted) {
+    throw new HostError("CANCELLED", "cancelled");
+  }
+  let res;
+  try {
+    const timeoutSignal = AbortSignal.timeout(ms);
+    const signal = sig ? AbortSignal.any([sig, timeoutSignal]) : timeoutSignal;
+    res = await fetch(url, {
+      method,
+      headers: encoded.headers,
+      body: encoded.body,
+      redirect: "follow",
+      signal
+    });
+  } catch (cause) {
+    if (sig?.aborted) {
+      throw new HostError("CANCELLED", "cancelled", { cause });
+    }
+    const msg = errText(cause);
+    if (/aborted|timeout/i.test(msg)) {
+      throw new HostError("HTTP_TIMEOUT", "http: timeout", { cause });
+    }
+    throw new HostError("HTTP_FAILED", `http: ${msg}`, { cause });
+  }
+  const contentLength = Number(res.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > HTTP_MAX_BYTES) {
+    throw new HostError("HTTP_TOO_LARGE", "http: response too large");
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.byteLength > HTTP_MAX_BYTES) {
+    throw new HostError("HTTP_TOO_LARGE", "http: response too large");
+  }
+  const text = buf.toString("utf8");
+  const headerObj = headersToObject(res.headers);
+  return {
+    ok: res.ok,
+    status: res.status,
+    headers: headerObj,
+    text,
+    json: parseJson(headerObj["content-type"] ?? "", text)
+  };
+}
+
+// src/apps/apps-manager.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function defineDashboard(def) {
+  if (!def.name || !def.description) {
+    throw new HostError("INVALID_DASHBOARD", "defineDashboard requires name and description");
+  }
+  if (!def.api || typeof def.api !== "object") {
+    throw new HostError("INVALID_DASHBOARD", "defineDashboard.api must be an object");
+  }
+  return def;
+}
+function publicAppConfig(config) {
+  return {
+    theme: config.theme,
+    palette: config.palette,
+    locale: config.locale,
+    chatLanguage: config.chatLanguage,
+    hostPort: config.hostPort,
+    llm: config.llm
+  };
+}
+function makeFileStorage(appDir, fileName) {
+  const fp = path8__default.join(appDir, "storage", fileName);
+  const read = () => {
+    try {
+      const parsed = JSON.parse(readFileSync(fp, "utf8"));
+      return isRecord2(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  };
+  const write = (obj) => {
+    mkdirSync(path8__default.dirname(fp), { recursive: true });
+    writeFileSync(fp, JSON.stringify(obj, null, 2));
+  };
+  return {
+    async get(key) {
+      const obj = read();
+      return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : null;
+    },
+    async set(key, value) {
+      const obj = read();
+      obj[key] = value;
+      write(obj);
+    },
+    async delete(key) {
+      const obj = read();
+      delete obj[key];
+      write(obj);
+    },
+    async clear() {
+      write({});
+    },
+    table(name) {
+      const safe = name.replace(/[^A-Za-z0-9_-]/g, "_");
+      return makeFileStorage(appDir, `${safe}.storage.json`);
+    }
+  };
+}
+function resolveAppModule(fromFile, spec, appDir) {
+  const root = path8__default.resolve(appDir);
+  const base = spec.startsWith(".") ? path8__default.resolve(path8__default.dirname(fromFile), spec) : path8__default.resolve(root, spec);
+  const resolved = path8__default.resolve(base);
+  const prefix = root.endsWith(path8__default.sep) ? root : `${root}${path8__default.sep}`;
+  if (resolved !== root && !resolved.startsWith(prefix)) {
+    throw new HostError("BACKEND_IMPORT", `backend import escapes app dir: ${spec}`);
+  }
+  const candidates = [
+    resolved,
+    `${resolved}.ts`,
+    `${resolved}.js`,
+    `${resolved}.tsx`,
+    path8__default.join(resolved, "index.ts"),
+    path8__default.join(resolved, "index.js"),
+    path8__default.join(resolved, "index.tsx")
+  ];
+  for (const c of candidates) {
+    if (existsSync(c) && statSync(c).isFile()) {
+      return c;
+    }
+  }
+  throw new HostError(
+    "BACKEND_IMPORT",
+    `cannot resolve '${spec}' from ${path8__default.relative(appDir, fromFile)}`
+  );
+}
+function asDashboardDef(value) {
+  const exported = isRecord2(value) && "default" in value ? value.default : value;
+  if (!isRecord2(exported)) {
+    throw new HostError("INVALID_DASHBOARD", "main.api must export a dashboard");
+  }
+  if (typeof exported.name !== "string" || typeof exported.description !== "string") {
+    throw new HostError("INVALID_DASHBOARD", "dashboard requires name and description");
+  }
+  if (!isRecord2(exported.api)) {
+    throw new HostError("INVALID_DASHBOARD", "dashboard.api must be an object");
+  }
+  const api = {};
+  for (const [key, fn] of Object.entries(exported.api)) {
+    if (typeof fn === "function") {
+      api[key] = fn;
+    }
+  }
+  const state = isRecord2(exported.state) ? exported.state : void 0;
+  return { name: exported.name, description: exported.description, api, state };
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new HostError("CANCELLED", "cancelled");
+  }
+}
+var AppsManager = class {
+  constructor(paths, capabilities, git2, config) {
+    this.paths = paths;
+    this.capabilities = capabilities;
+    this.git = git2;
+    this.config = config;
+  }
+  paths;
+  capabilities;
+  git;
+  config;
+  dashboardCache = /* @__PURE__ */ new Map();
+  uiCompiler = null;
+  /** Wire UI compiler for invalidate + reload (createHost calls this). */
+  setUiCompiler(compiler) {
+    this.uiCompiler = compiler;
+  }
+  dirOf(appId) {
+    return this.paths.appDir(asAppId(appId));
+  }
+  async list() {
+    const appsDir = this.paths.appsDir();
+    let names;
+    try {
+      names = readdirSync(appsDir);
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const name of names) {
+      const full = path8__default.join(appsDir, name);
+      try {
+        if (!statSync(full).isDirectory()) continue;
+        if (!isAppId(name)) continue;
+        const item = await this.readAppItem(name);
+        if (item) out.push(item);
+      } catch {
+      }
+    }
+    return out;
+  }
+  async get(appId) {
+    try {
+      return await this.readAppItem(asAppId(appId));
+    } catch {
+      return null;
+    }
+  }
+  async register(appId, files) {
+    const id = asAppId(appId);
+    if (!files["manifest.json"]) {
+      throw new HostError("MISSING_MANIFEST", "register requires manifest.json");
+    }
+    parseManifest(files["manifest.json"]);
+    for (const [rel, content] of Object.entries(files)) {
+      if (rel.includes("..") || path8__default.isAbsolute(rel)) {
+        throw new HostError("PATH_ESCAPE", `unsafe relative path: ${rel}`);
+      }
+      const dest = this.paths.appFile(id, rel);
+      mkdirSync(path8__default.dirname(dest), { recursive: true });
+      writeFileSync(dest, content, "utf8");
+    }
+    const dir = this.dirOf(id);
+    await this.afterMutate(dir, { commitMessage: "registerAppFromFiles" });
+    const item = await this.readAppItem(id);
+    if (!item) {
+      throw new HostError("APP_NOT_FOUND", `failed to register ${id}`);
+    }
+    return item;
+  }
+  async listFiles(appId) {
+    asAppId(appId);
+    if (!await this.get(appId)) {
+      throw new HostError("APP_NOT_FOUND", `app not found: ${appId}`);
+    }
+    return listAppFiles(this.paths, appId);
+  }
+  async readFile(appId, relPath, range) {
+    asAppId(appId);
+    if (!await this.get(appId)) {
+      throw new HostError("APP_NOT_FOUND", `app not found: ${appId}`);
+    }
+    return readAppFile(this.paths, appId, relPath, range);
+  }
+  async writeFile(appId, relPath, content, opts) {
+    asAppId(appId);
+    if (!await this.get(appId)) {
+      throw new HostError("APP_NOT_FOUND", `app not found: ${appId}`);
+    }
+    const written = writeAppFile(this.paths, appId, relPath, content);
+    const after = await this.afterMutate(this.dirOf(appId), {
+      commitMessage: `write ${written.path}`,
+      commit: opts?.commit
+    });
+    return { ...written, ...after };
+  }
+  async editFile(appId, relPath, edits, opts) {
+    asAppId(appId);
+    if (!await this.get(appId)) {
+      throw new HostError("APP_NOT_FOUND", `app not found: ${appId}`);
+    }
+    const edited = editAppFile(this.paths, appId, relPath, edits);
+    const after = await this.afterMutate(this.dirOf(appId), {
+      commitMessage: `edit ${edited.path}`,
+      commit: opts?.commit
+    });
+    return { ...edited, ...after };
+  }
+  async deleteFile(appId, relPath, opts) {
+    asAppId(appId);
+    if (!await this.get(appId)) {
+      throw new HostError("APP_NOT_FOUND", `app not found: ${appId}`);
+    }
+    const deleted = deleteAppFile(this.paths, appId, relPath);
+    const after = await this.afterMutate(this.dirOf(appId), {
+      commitMessage: `delete ${deleted.path}`,
+      commit: opts?.commit
+    });
+    return { ...deleted, ...after };
+  }
+  /**
+   * Validate + sync-compile api/ui. On success, auto-commit if the worktree is dirty.
+   * Replaces the old lightweight mini_app_validate tool.
+   */
+  async reload(appId) {
+    const errors = [];
+    if (!isAppId(appId)) {
+      errors.push("appId must be reverse-DNS (e.g. com.example.todo)");
+      return { ok: false, errors, path: "" };
+    }
+    const dir = this.dirOf(appId);
+    const app = await this.get(appId);
+    if (!app) {
+      errors.push("app not registered; call mini_app_register({ appId, files })");
+      return { ok: false, errors, path: dir };
+    }
+    const manPath = this.paths.appFile(asAppId(appId), WorkspacePaths.Rel.manifest);
+    try {
+      parseManifest(readFileSync(manPath, "utf8"));
+    } catch (cause) {
+      const message = cause instanceof Error ? cause.message : String(cause);
+      errors.push(`manifest: ${message}`);
+    }
+    this.invalidate(dir);
+    let apiOk = false;
+    try {
+      const apiPath = path8__default.join(dir, "main.api.ts");
+      const apiJs = path8__default.join(dir, "main.api.js");
+      const srcPath = existsSync(apiPath) ? apiPath : apiJs;
+      if (!existsSync(srcPath)) {
+        errors.push("missing main.api.ts");
+      } else {
+        compileAppSource(readFileSync(srcPath, "utf8"));
+        this.loadMainApi(dir);
+        apiOk = true;
+      }
+    } catch (cause) {
+      const message = cause instanceof Error ? cause.message : String(cause);
+      errors.push(`main.api: ${message}`);
+    }
+    let uiOk = false;
+    if (this.uiCompiler) {
+      try {
+        await this.uiCompiler.compile(dir, { locale: this.config.locale });
+        uiOk = true;
+      } catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        errors.push(`ui: ${message}`);
+      }
+    } else {
+      errors.push("ui compiler not wired");
+    }
+    const ok = errors.length === 0;
+    let committed = null;
+    if (ok) {
+      await this.git.init(dir);
+      if (await this.git.isDirty(dir)) {
+        try {
+          const { commitId } = await this.git.commit(dir, "reload");
+          committed = { commitId, message: "reload" };
+        } catch (cause) {
+          const message = cause instanceof Error ? cause.message : String(cause);
+          errors.push(`commit: ${message}`);
+          return {
+            ok: false,
+            errors,
+            path: dir,
+            compiled: { api: apiOk, ui: uiOk },
+            committed: null
+          };
+        }
+      }
+    }
+    return {
+      ok: errors.length === 0,
+      errors,
+      path: dir,
+      compiled: { api: apiOk, ui: uiOk },
+      committed
+    };
+  }
+  async afterMutate(appDir, opts) {
+    this.invalidate(appDir);
+    await this.git.init(appDir);
+    if (opts.commit === false) {
+      return { committed: null };
+    }
+    try {
+      const { commitId } = await this.git.commit(appDir, opts.commitMessage);
+      return { committed: { commitId, message: opts.commitMessage } };
+    } catch {
+      return { committed: null };
+    }
+  }
+  async remove(appId) {
+    const id = asAppId(appId);
+    const dir = this.dirOf(id);
+    this.invalidate(dir);
+    await rm(dir, { recursive: true, force: true });
+  }
+  load(appId) {
+    const dir = this.dirOf(appId);
+    const mtime = this.dashboardMtime(dir);
+    const hit = this.dashboardCache.get(dir);
+    if (hit && hit.mtime === mtime) {
+      return hit;
+    }
+    const def = this.loadMainApi(dir);
+    const storage = makeFileStorage(dir, "main.storage.json");
+    const ctx = this.buildCtx(storage, def, asAppId(appId));
+    const rec = { mtime, def, ctx };
+    this.dashboardCache.set(dir, rec);
+    return rec;
+  }
+  async call(appId, method, args, signal) {
+    const { def, ctx } = this.load(appId);
+    const fn = def.api[method];
+    if (typeof fn !== "function") {
+      throw new HostError("METHOD_NOT_FOUND", `Method not found: ${method}`);
+    }
+    ctx.signal = signal;
+    throwIfAborted(signal);
+    return await fn(ctx, args ?? {});
+  }
+  invalidate(appDir) {
+    this.dashboardCache.delete(appDir);
+    this.uiCompiler?.invalidate(appDir);
+  }
+  async readAppItem(id) {
+    const dir = this.dirOf(id);
+    const manPath = this.paths.appFile(id, WorkspacePaths.Rel.manifest);
+    let raw;
+    try {
+      raw = readFileSync(manPath, "utf8");
+    } catch {
+      return null;
+    }
+    let man;
+    try {
+      man = parseManifest(raw);
+    } catch {
+      return null;
+    }
+    const commits = await this.git.commitCount(dir);
+    return {
+      id,
+      name: man.name,
+      description: man.description ?? "",
+      version: man.version,
+      acronym: acronymOf(man.name, man.acronym),
+      commits
+    };
+  }
+  dashboardMtime(appDir) {
+    let max = 0;
+    const bump = (p) => {
+      try {
+        const t = statSync(p).mtimeMs;
+        if (t > max) max = t;
+      } catch {
+      }
+    };
+    bump(path8__default.join(appDir, "manifest.json"));
+    bump(path8__default.join(appDir, "main.api.ts"));
+    bump(path8__default.join(appDir, "main.api.js"));
+    try {
+      const lib = path8__default.join(appDir, "lib");
+      for (const n of readdirSync(lib)) {
+        if (n.endsWith(".ts") || n.endsWith(".js")) {
+          bump(path8__default.join(lib, n));
+        }
+      }
+    } catch {
+    }
+    return max;
+  }
+  loadMainApi(appDir) {
+    const loaded = /* @__PURE__ */ new Map();
+    const fp = path8__default.join(appDir, "main.api.ts");
+    const fpJs = path8__default.join(appDir, "main.api.js");
+    const srcPath = existsSync(fp) ? fp : fpJs;
+    if (!existsSync(srcPath)) {
+      throw new HostError("MISSING_MAIN_API", "missing main.api.ts");
+    }
+    const exported = this.loadAppFile(srcPath, appDir, loaded);
+    return asDashboardDef(exported);
+  }
+  loadAppFile(file, appDir, loaded) {
+    const hit = loaded.get(file);
+    if (hit !== void 0) {
+      return hit;
+    }
+    const mod = { exports: {} };
+    loaded.set(file, mod.exports);
+    const src = compileAppSource(readFileSync(file, "utf8"));
+    const req = (spec) => {
+      if (spec === "@monkeyagent/dashboard") {
+        return { defineDashboard, default: defineDashboard };
+      }
+      if (spec.startsWith(".") || spec.startsWith("lib/") || spec.startsWith("components/")) {
+        const next = resolveAppModule(file, spec, appDir);
+        return this.loadAppFile(next, appDir, loaded);
+      }
+      throw new HostError(
+        "BACKEND_IMPORT",
+        `backend cannot import '${spec}'. Only @monkeyagent/dashboard and relative ./lib ./components`
+      );
+    };
+    const fn = new Function(
+      "module",
+      "exports",
+      "require",
+      `${src}
+return module.exports;`
+    );
+    const exported = fn(mod, mod.exports, req);
+    const value = exported ?? mod.exports;
+    loaded.set(file, value);
+    return value;
+  }
+  buildCtx(storage, def, appId) {
+    const caps = this.capabilities;
+    const appDir = this.paths.appDir(appId);
+    const box = {};
+    const callCtx = {
+      appId,
+      appDir,
+      hostLlm: this.config.llm ?? void 0
+    };
+    Object.defineProperty(callCtx, "signal", {
+      enumerable: true,
+      configurable: true,
+      get: () => box.signal
+    });
+    const bound = bindCapsToContext(callCtx, caps);
+    const { credentials: getCredentials, config: getConfig, ...capMethods } = bound;
+    const ctx = {
+      appId,
+      appDir,
+      storage,
+      state: def.state ?? {},
+      credentials: {},
+      log: (...a) => {
+        console.log("[mini-api]", ...a);
+      },
+      push: (_method, _params) => {
+      },
+      ...capMethods,
+      http: (url, opts) => httpRequest(url, { ...opts, signal: box.signal }),
+      system: {
+        async metrics() {
+          const cpus = os.cpus();
+          const load = os.loadavg();
+          const total = os.totalmem();
+          const free = os.freemem();
+          return {
+            platform: os.platform(),
+            arch: os.arch(),
+            hostname: os.hostname(),
+            uptimeSec: Math.floor(os.uptime()),
+            loadavg: { "1m": load[0], "5m": load[1], "15m": load[2] },
+            memory: { total, free, used: total - free, usedRatio: total ? (total - free) / total : 0 },
+            cpu: { count: cpus.length, model: cpus[0]?.model ?? "unknown", speedMHz: cpus[0]?.speed ?? 0 },
+            collectedAt: Date.now()
+          };
+        }
+      },
+      config: {}
+    };
+    Object.defineProperty(ctx, "signal", {
+      enumerable: true,
+      get: () => box.signal,
+      set: (value) => {
+        box.signal = value;
+      }
+    });
+    Object.defineProperty(ctx, "credentials", {
+      enumerable: true,
+      get: () => getCredentials()
+    });
+    Object.defineProperty(ctx, "config", {
+      enumerable: true,
+      get: () => caps.config ? getConfig() : publicAppConfig(this.config)
+    });
+    return ctx;
+  }
+};
+function listStorageTables(dir) {
+  try {
+    const names = fs4__default.existsSync(dir) ? fs4__default.readdirSync(dir).filter((n) => n.endsWith(".json")) : [];
+    return names.map((n) => {
+      const fp = path8__default.join(dir, n);
+      const st = fs4__default.statSync(fp);
+      return {
+        name: n.replace(/\.json$/, ""),
+        size: st.size,
+        updatedAt: st.mtime.toISOString()
+      };
+    }).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  } catch {
+    return [];
+  }
+}
+function storageTablePath(dir, table) {
+  return path8__default.join(dir, `${path8__default.basename(String(table ?? ""))}.json`);
+}
+function readJsonFile(fp, fallback = null) {
+  try {
+    return JSON.parse(fs4__default.readFileSync(fp, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+var requireFromHere = createRequire(import.meta.url);
+var uiDistDir = null;
+var esbuildReady = null;
+function distLooksValid(dir) {
+  return fs4.existsSync(path8.join(dir, "index.js"));
+}
+function resolveUiDistDir() {
+  if (uiDistDir) return uiDistDir;
+  const tryResolve = (fromFile) => {
+    try {
+      const req = createRequire(fromFile);
+      const pkgJson = req.resolve("@monkey-mini-app/ui/package.json");
+      const dir = path8.join(path8.dirname(pkgJson), "dist");
+      return distLooksValid(dir) ? dir : null;
+    } catch {
+      return null;
+    }
+  };
+  const candidates = [
+    tryResolve(path8.join(path8.dirname(fileURLToPath(import.meta.url)), "ui-compiler.ts")),
+    tryResolve(import.meta.url),
+    // bundled as packages/dsh/lib/index.js → walk up to repo packages/ui/dist
+    (() => {
+      const here = path8.dirname(fileURLToPath(import.meta.url));
+      const guesses = [
+        path8.resolve(here, "../../../ui/dist"),
+        path8.resolve(here, "../../ui/dist"),
+        path8.resolve(here, "../../../../packages/ui/dist")
+      ];
+      for (const g of guesses) {
+        if (distLooksValid(g)) return g;
+      }
+      return null;
+    })()
+  ];
+  for (const dir of candidates) {
+    if (dir) {
+      uiDistDir = dir;
+      return dir;
+    }
+  }
+  try {
+    const pkgJson = requireFromHere.resolve("@monkey-mini-app/ui/package.json");
+    const dir = path8.join(path8.dirname(pkgJson), "dist");
+    if (distLooksValid(dir)) {
+      uiDistDir = dir;
+      return dir;
+    }
+  } catch {
+  }
+  throw new HostError(
+    "UI_DIST_MISSING",
+    "@monkey-mini-app/ui dist not found \u2014 run: node scripts/build-ui.mjs && ensure @monkey-mini-app/ui is a dependency of the running plugin"
+  );
+}
+async function loadEsbuild() {
+  try {
+    const mod2 = await import(
+      /* @vite-ignore */
+      'esbuild'
+    );
+    if (typeof mod2.build === "function") return mod2;
+  } catch {
+  }
+  const mod = await import(
+    /* @vite-ignore */
+    'esbuild-wasm'
+  );
+  if (typeof mod.initialize === "function") {
+    await mod.initialize();
+  }
+  return mod;
+}
+function getEsbuild() {
+  if (!esbuildReady) esbuildReady = loadEsbuild();
+  return esbuildReady;
+}
+function uiLocale(locale) {
+  return locale === "en" ? "en" : "zh";
+}
+function appIdOf(appDir) {
+  try {
+    const man = JSON.parse(fs4.readFileSync(path8.join(appDir, "manifest.json"), "utf8"));
+    if (typeof man.id === "string" && man.id) return man.id;
+  } catch {
+  }
+  return path8.basename(path8.resolve(appDir));
+}
+function findUiEntry(appDir) {
+  for (const name of ["ui.tsx", "ui.ts", "App.tsx", "App.ts"]) {
+    const p = path8.join(appDir, name);
+    if (fs4.existsSync(p)) return p;
+  }
+  throw new HostError("MISSING_UI_ENTRY", "missing ui entry (ui.tsx / App.tsx)");
+}
+function makeUiPlugin(distDir, appId) {
+  const req = createRequire(path8.join(distDir, "index.js"));
+  return {
+    name: "monkey-mini-app-ui",
+    setup(build) {
+      build.onResolve({ filter: /(?:^|[\\/])main\.api\.(ts|js)$/ }, () => ({
+        path: "main.api.ts",
+        namespace: "mma-forbidden"
+      }));
+      build.onLoad({ filter: /.*/, namespace: "mma-forbidden" }, () => ({
+        errors: [
+          {
+            text: "UI cannot import main.api.ts; use useDashboardApi() from @monkeyagent/host"
+          }
+        ]
+      }));
+      build.onResolve({ filter: /^@monkey-mini-app\/ui$/ }, () => ({
+        path: path8.join(distDir, "index.js")
+      }));
+      build.onResolve({ filter: /^react(-dom)?(\/.*)?$/ }, (args) => {
+        try {
+          return { path: req.resolve(args.path) };
+        } catch {
+          return { path: args.path, external: true };
+        }
+      });
+      build.onResolve({ filter: /^@monkeyagent\/host$/ }, () => ({
+        namespace: "mma-host",
+        path: "useDashboardApi"
+      }));
+      build.onLoad({ filter: /.*/, namespace: "mma-host" }, () => ({
+        contents: `
+import { useCallback } from "react";
+const __MMA_APP_ID = ${JSON.stringify(appId)};
+export function useDashboardApi() {
+  const call = useCallback(async (m, a) => {
+    const j = await fetch("/api/call", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ appId: __MMA_APP_ID, method: m, args: a || {} }),
+    }).then((r) => r.json());
+    if (!j.ok) throw new Error(j.error || "call failed");
+    return j.value;
+  }, []);
+  return { call };
+}
+`,
+        loader: "js"
+      }));
+    }
+  };
+}
+function walkMtime(dir, bump) {
+  for (const n of fs4.readdirSync(dir)) {
+    const full = path8.join(dir, n);
+    const st = fs4.statSync(full);
+    if (st.isDirectory()) {
+      if (n === "storage" || n === ".git" || n === "node_modules" || n === ".ui-build") continue;
+      walkMtime(full, bump);
+    } else if (/\.(tsx?|jsx?|json|css)$/.test(n)) {
+      bump(full);
+    }
+  }
+}
+var UiCompiler = class {
+  constructor(paths) {
+    this.paths = paths;
+  }
+  paths;
+  buildCache = /* @__PURE__ */ new Map();
+  invalidate(appDir) {
+    this.buildCache.delete(appDir);
+  }
+  cacheSize() {
+    return this.buildCache.size;
+  }
+  async compile(appDir, options) {
+    const locale = uiLocale(options.locale);
+    const sig = `${this.cacheSig(appDir)}-${locale}`;
+    const hit = this.buildCache.get(appDir);
+    if (hit && hit.sig === sig) return hit.files;
+    const cacheKey = this.cacheKey(appDir, sig);
+    const cacheDir = path8.join(this.paths.uiCacheDir(), cacheKey);
+    try {
+      if (fs4.existsSync(path8.join(cacheDir, "entry.js"))) {
+        const names = fs4.readdirSync(cacheDir).filter((n) => n.endsWith(".js"));
+        const files2 = names.sort((a, b) => a === "entry.js" ? -1 : b === "entry.js" ? 1 : a.localeCompare(b)).map((n) => ({ name: n, contents: fs4.readFileSync(path8.join(cacheDir, n)) }));
+        this.buildCache.set(appDir, { sig, files: files2 });
+        return files2;
+      }
+    } catch {
+    }
+    const distDir = resolveUiDistDir();
+    const esbuild = await getEsbuild();
+    const entry = findUiEntry(appDir);
+    const uiRel = path8.basename(entry);
+    const wrapper = `
+import { createRoot } from "react-dom/client";
+import { UiProvider } from "@monkey-mini-app/ui";
+import Ui from "./${uiRel}";
+const rootEl = document.getElementById("root");
+if (rootEl) {
+  rootEl.className = "";
+  rootEl.removeAttribute("role");
+  rootEl.removeAttribute("aria-label");
+  rootEl.replaceChildren();
+  createRoot(rootEl).render(<UiProvider locale=${JSON.stringify(locale)}><Ui /></UiProvider>);
+}
+`;
+    let res;
+    try {
+      res = await esbuild.build({
+        stdin: {
+          contents: wrapper,
+          resolveDir: appDir,
+          sourcefile: "entry.tsx",
+          loader: "tsx"
+        },
+        outfile: path8.join(appDir, ".ui-build", "entry.js"),
+        bundle: true,
+        format: "esm",
+        write: false,
+        platform: "browser",
+        target: "es2020",
+        plugins: [makeUiPlugin(distDir, appIdOf(appDir))],
+        loader: { ".tsx": "tsx", ".ts": "ts" },
+        jsx: "automatic",
+        define: { "process.env.NODE_ENV": '"production"' },
+        minify: true,
+        legalComments: "none",
+        logLevel: "silent"
+      });
+    } catch (cause) {
+      const message = cause instanceof Error ? cause.message : String(cause);
+      throw new HostError("UI_COMPILE_FAILED", message, { cause });
+    }
+    const output = res.outputFiles;
+    if (!output || output.length === 0) {
+      throw new HostError("UI_COMPILE_FAILED", "esbuild produced no output");
+    }
+    const files = output.map((o) => ({ name: path8.basename(o.path), contents: o.contents })).sort((a, b) => {
+      const am = a.name === "entry.js" ? 0 : 1;
+      const bm = b.name === "entry.js" ? 0 : 1;
+      return am - bm || a.name.localeCompare(b.name);
+    });
+    try {
+      fs4.mkdirSync(cacheDir, { recursive: true });
+      for (const f of files) {
+        fs4.writeFileSync(path8.join(cacheDir, f.name), f.contents);
+      }
+    } catch {
+    }
+    this.buildCache.set(appDir, { sig, files });
+    return files;
+  }
+  cacheKey(appDir, sig) {
+    const id = path8.basename(path8.resolve(appDir)).replace(/[^A-Za-z0-9_-]/g, "_");
+    return `${id}-${sig}`;
+  }
+  cacheSig(appDir) {
+    let max = 0;
+    let count = 0;
+    const bump = (fp) => {
+      try {
+        const t = fs4.statSync(fp).mtimeMs;
+        if (t > max) max = t;
+        count++;
+      } catch {
+      }
+    };
+    for (const name of ["ui.tsx", "ui.ts", "App.tsx", "App.ts", "manifest.json"]) {
+      bump(path8.join(appDir, name));
+    }
+    try {
+      walkMtime(appDir, bump);
+    } catch {
+    }
+    try {
+      walkMtime(resolveUiDistDir(), (fp) => {
+        if (/\.(tsx?|jsx?|mjs|cjs|js|css|json)$/.test(path8.basename(fp))) {
+          bump(fp);
+        }
+      });
+    } catch {
+    }
+    return `${max.toString(36)}-${count.toString(36)}`;
+  }
+};
+
+// src/config/defaults.ts
+var DEFAULT_HOST_CONFIG_SEED = Object.freeze({
+  runtimeRoot: "~/.monkey-mini-app/runtime",
+  hostPort: 17880,
+  theme: "light",
+  palette: "default",
+  locale: "zh-CN",
+  chatLanguage: "zh-CN",
+  llm: null
+});
+
+// src/types.ts
+var THEME_IDS = ["light", "dark"];
+var PALETTE_IDS = [
+  "default",
+  "tokyo",
+  "forest",
+  "matcha",
+  "yellow",
+  "zoro",
+  "hokage",
+  "slate"
+];
+var LOCALE_IDS = ["zh-CN", "en"];
+
+// src/config/parse.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireField(raw, key) {
+  if (!(key in raw) || raw[key] === void 0) {
+    throw new HostConfigError(`host config missing ${key}`);
+  }
+  return raw[key];
+}
+function parseEnum(value, key, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new HostConfigError(`host config ${key} is invalid`);
+  }
+  return value;
+}
+function parseHostPort(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 65535) {
+    throw new HostConfigError("host config hostPort is invalid");
+  }
+  return value;
+}
+function parsePalette(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new HostConfigError("host config palette is invalid");
+  }
+  return value.trim();
+}
+function parseLlm(value) {
+  if (value === null) {
+    return null;
+  }
+  if (!isRecord3(value)) {
+    throw new HostConfigError("host config llm is invalid");
+  }
+  const provider = value.provider;
+  const model = value.model;
+  if (typeof provider !== "string" || provider.length === 0) {
+    throw new HostConfigError("host config llm.provider is invalid");
+  }
+  if (typeof model !== "string" || model.length === 0) {
+    throw new HostConfigError("host config llm.model is invalid");
+  }
+  return { provider, model };
+}
+function parseHostConfig(raw) {
+  if (!isRecord3(raw)) {
+    throw new HostConfigError("host config must be an object");
+  }
+  const runtimeRootRaw = requireField(raw, "runtimeRoot");
+  if (typeof runtimeRootRaw !== "string") {
+    throw new HostConfigError("host config runtimeRoot is invalid");
+  }
+  let runtimeRoot;
+  try {
+    runtimeRoot = asAbsolutePath(runtimeRootRaw);
+  } catch (cause) {
+    throw new HostConfigError("host config runtimeRoot must be an absolute path", { cause });
+  }
+  return {
+    runtimeRoot,
+    hostPort: parseHostPort(requireField(raw, "hostPort")),
+    theme: parseEnum(requireField(raw, "theme"), "theme", THEME_IDS),
+    palette: parsePalette(requireField(raw, "palette")),
+    locale: parseEnum(requireField(raw, "locale"), "locale", LOCALE_IDS),
+    chatLanguage: parseEnum(
+      requireField(raw, "chatLanguage"),
+      "chatLanguage",
+      LOCALE_IDS
+    ),
+    llm: parseLlm(requireField(raw, "llm"))
+  };
+}
+
+// src/config/bootstrap.ts
+function expandHome(p) {
+  if (p === "~") {
+    return homedir();
+  }
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return path8__default.join(homedir(), p.slice(2));
+  }
+  return p;
+}
+function resolveRuntimeRoot(p) {
+  return path8__default.resolve(expandHome(p));
+}
+function bootstrapHostConfig(input) {
+  const merged = { ...DEFAULT_HOST_CONFIG_SEED };
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  if (typeof merged.runtimeRoot === "string") {
+    merged.runtimeRoot = resolveRuntimeRoot(merged.runtimeRoot);
+  }
+  return parseHostConfig(merged);
+}
+function loadHostConfig(paths) {
+  const file = paths.hostConfigFile();
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch (cause) {
+    throw new HostConfigError(`host config not found: ${file}`, {
+      code: "HOST_CONFIG_NOT_FOUND",
+      cause
+    });
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (cause) {
+    throw new HostConfigError(`host config is not valid JSON: ${file}`, {
+      cause
+    });
+  }
+  return parseHostConfig(raw);
+}
+function writeHostConfig(paths, config) {
+  const payload = {
+    runtimeRoot: config.runtimeRoot,
+    hostPort: config.hostPort,
+    theme: config.theme,
+    palette: config.palette,
+    locale: config.locale,
+    chatLanguage: config.chatLanguage,
+    llm: config.llm
+  };
+  writeFileSync(paths.hostConfigFile(), `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+
+// src/events/host-events.ts
+var HostEventBus = class {
+  listeners = /* @__PURE__ */ new Set();
+  seq = 0;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  emit(event) {
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  /** Monotonic id for SSE `id:` fields. */
+  nextId() {
+    this.seq += 1;
+    return this.seq;
+  }
+};
+function formatSse(event, id) {
+  return `id: ${id}
+event: ${event.type}
+data: ${JSON.stringify({
+    appId: event.appId,
+    title: event.title
+  })}
+
+`;
+}
+var COMMIT_TTL_MS = 6e4;
+var DEFAULT_AUTHOR = {
+  name: "mini-agent",
+  email: "agent@local"
+};
+var GITIGNORE = `storage/
+.DS_Store
+node_modules/
+.ui-build/
+`;
+async function resolveHead(dir) {
+  try {
+    return await git.resolveRef({ fs: fs4__default, dir, ref: "HEAD" });
+  } catch {
+    return null;
+  }
+}
+async function blobOidAtPath(dir, treeOid, filepath) {
+  const parts = filepath.split("/").filter(Boolean);
+  let oid = treeOid;
+  for (let i = 0; i < parts.length; i++) {
+    const { tree } = await git.readTree({ fs: fs4__default, dir, oid });
+    const entry = tree.find((e) => e.path === parts[i]);
+    if (!entry) return null;
+    if (i === parts.length - 1) {
+      return entry.type === "blob" ? entry.oid : null;
+    }
+    if (entry.type !== "tree") return null;
+    oid = entry.oid;
+  }
+  return null;
+}
+async function readBlobText(dir, oid) {
+  try {
+    const { blob } = await git.readBlob({ fs: fs4__default, dir, oid });
+    const buf = Buffer.from(blob);
+    if (buf.includes(0)) {
+      return null;
+    }
+    return buf.toString("utf8");
+  } catch {
+    return null;
+  }
+}
+async function treeFileMap(dir, treeOid, prefix = "") {
+  const map = /* @__PURE__ */ new Map();
+  const tree = await git.readTree({ fs: fs4__default, dir, oid: treeOid });
+  for (const entry of tree.tree) {
+    const fp = prefix ? `${prefix}/${entry.path}` : entry.path;
+    if (entry.type === "blob") {
+      map.set(fp, entry.oid);
+    } else if (entry.type === "tree") {
+      const sub = await treeFileMap(dir, entry.oid, fp);
+      for (const [k, v] of sub) {
+        map.set(k, v);
+      }
+    }
+  }
+  return map;
+}
+function countLines(text) {
+  if (text === "") {
+    return 0;
+  }
+  return text.replace(/\n$/, "").split("\n").length;
+}
+function lineStats(before, after) {
+  if (before === null && after === null) {
+    return { add: -1, del: -1 };
+  }
+  if (before === null) {
+    return { add: countLines(after ?? ""), del: 0 };
+  }
+  if (after === null) {
+    return { add: 0, del: countLines(before) };
+  }
+  const a = before.replace(/\n$/, "").split("\n");
+  const b = after.replace(/\n$/, "").split("\n");
+  const dp = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+    }
+  }
+  const lcs = dp[a.length][b.length];
+  return { add: b.length - lcs, del: a.length - lcs };
+}
+function unifiedDiff(before, after) {
+  const a = before == null ? [] : before.replace(/\n$/, "").split("\n");
+  const b = after == null ? [] : after.replace(/\n$/, "").split("\n");
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length || j < b.length) {
+    if (i < a.length && j < b.length && a[i] === b[j]) {
+      out.push(` ${a[i]}`);
+      i++;
+      j++;
+      continue;
+    }
+    let foundJ = -1;
+    for (let jj = j; jj < Math.min(j + 40, b.length); jj++) {
+      if (a[i] !== void 0 && a[i] === b[jj]) {
+        foundJ = jj;
+        break;
+      }
+    }
+    let foundI = -1;
+    for (let ii = i; ii < Math.min(i + 40, a.length); ii++) {
+      if (b[j] !== void 0 && b[j] === a[ii]) {
+        foundI = ii;
+        break;
+      }
+    }
+    if (foundJ >= 0 && (foundI < 0 || foundJ - j <= foundI - i)) {
+      while (j < foundJ) {
+        out.push(`+${b[j]}`);
+        j++;
+      }
+      continue;
+    }
+    if (foundI >= 0) {
+      while (i < foundI) {
+        out.push(`-${a[i]}`);
+        i++;
+      }
+      continue;
+    }
+    if (i < a.length) {
+      out.push(`-${a[i]}`);
+      i++;
+    }
+    if (j < b.length) {
+      out.push(`+${b[j]}`);
+      j++;
+    }
+  }
+  return out.join("\n");
+}
+async function ensureGitignore(dir) {
+  const p = path8__default.join(dir, ".gitignore");
+  let existing = "";
+  try {
+    existing = await fsp.readFile(p, "utf8");
+  } catch {
+    await fsp.writeFile(p, GITIGNORE, "utf8");
+    return;
+  }
+  const missing = GITIGNORE.split("\n").filter((line) => {
+    const t = line.trim();
+    return t && !existing.split("\n").some((e) => e.trim() === t);
+  });
+  if (missing.length > 0) {
+    const next = existing.endsWith("\n") || existing.length === 0 ? `${existing}${missing.join("\n")}
+` : `${existing}
+${missing.join("\n")}
+`;
+    await fsp.writeFile(p, next, "utf8");
+  }
+}
+async function listBackupRefs(dir) {
+  const refsDir = path8__default.join(dir, ".git", "refs", "backup");
+  try {
+    const names = await fsp.readdir(refsDir);
+    const out = [];
+    for (const name of names) {
+      const oid = (await fsp.readFile(path8__default.join(refsDir, name), "utf8")).trim();
+      out.push({ name: `backup/${name}`, oid });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function stageAll(dir) {
+  const status = await git.statusMatrix({ fs: fs4__default, dir });
+  for (const [filepath, headStatus, workdirStatus] of status) {
+    if (filepath === ".") continue;
+    try {
+      if (workdirStatus === 0) {
+        if (headStatus !== 0) {
+          await git.remove({ fs: fs4__default, dir, filepath });
+        }
+      } else {
+        await git.add({ fs: fs4__default, dir, filepath });
+      }
+    } catch {
+    }
+  }
+}
+var GitHistory = class {
+  commitCountCache = /* @__PURE__ */ new Map();
+  invalidateCount(dir) {
+    this.commitCountCache.delete(dir);
+  }
+  async init(dir) {
+    await fsp.mkdir(dir, { recursive: true });
+    const gitdir = path8__default.join(dir, ".git");
+    try {
+      await fsp.access(gitdir);
+    } catch {
+      await git.init({ fs: fs4__default, dir, defaultBranch: "main" });
+    }
+    await ensureGitignore(dir);
+    try {
+      await git.resolveRef({ fs: fs4__default, dir, ref: "main" });
+    } catch {
+      await git.add({ fs: fs4__default, dir, filepath: ".gitignore" });
+      await git.commit({
+        fs: fs4__default,
+        dir,
+        message: "init",
+        author: DEFAULT_AUTHOR
+      });
+      this.invalidateCount(dir);
+    }
+  }
+  async commit(dir, message, opts) {
+    await stageAll(dir);
+    const commitId = await git.commit({
+      fs: fs4__default,
+      dir,
+      message,
+      author: opts?.author ?? DEFAULT_AUTHOR
+    });
+    this.invalidateCount(dir);
+    return { commitId };
+  }
+  /**
+   * True when worktree or index differs from HEAD.
+   * Content-hashes tracked files that statusMatrix marks clean — isomorphic-git
+   * can miss same-size / same-mtime edits (see stageAll comment).
+   */
+  async isDirty(dir) {
+    try {
+      const status = await git.statusMatrix({ fs: fs4__default, dir });
+      for (const [filepath, head, workdir, stage] of status) {
+        if (filepath === ".") continue;
+        if (head !== workdir || workdir !== stage) return true;
+      }
+      const headOid = await resolveHead(dir);
+      if (!headOid) return false;
+      const { commit } = await git.readCommit({ fs: fs4__default, dir, oid: headOid });
+      for (const [filepath, head, workdir] of status) {
+        if (filepath === "." || head !== 1 || workdir !== 1) continue;
+        try {
+          const workBuf = await fsp.readFile(path8__default.join(dir, filepath));
+          const { oid: workOid } = await git.hashBlob({ object: workBuf });
+          const headBlobOid = await blobOidAtPath(dir, commit.tree, filepath);
+          if (!headBlobOid || headBlobOid !== workOid) return true;
+        } catch {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async listCommits(dir, opts) {
+    const limit = opts?.limit ?? 100;
+    const nodesMap = /* @__PURE__ */ new Map();
+    const tips = [];
+    let head = "";
+    try {
+      head = await git.resolveRef({ fs: fs4__default, dir, ref: "HEAD" });
+      tips.push({ name: "main", commitId: head });
+    } catch {
+      return { head: "", nodes: [], tips: [] };
+    }
+    const walk = async (oid, remaining) => {
+      if (remaining <= 0 || nodesMap.has(oid)) {
+        return;
+      }
+      const commit = await git.readCommit({ fs: fs4__default, dir, oid });
+      const parentIds = commit.commit.parent ?? [];
+      nodesMap.set(oid, {
+        id: oid,
+        parentIds,
+        message: commit.commit.message.trim(),
+        time: new Date(commit.commit.author.timestamp * 1e3).toISOString()
+      });
+      for (const parent of parentIds) {
+        await walk(parent, remaining - 1);
+      }
+    };
+    await walk(head, limit);
+    const backups = await listBackupRefs(dir);
+    for (const b of backups) {
+      tips.push({ name: b.name, commitId: b.oid });
+      await walk(b.oid, limit);
+    }
+    return {
+      head,
+      nodes: [...nodesMap.values()],
+      tips
+    };
+  }
+  async revert(dir, commitId, opts) {
+    const target = await git.readCommit({ fs: fs4__default, dir, oid: commitId });
+    const parents = target.commit.parent;
+    if (parents.length !== 1) {
+      throw new HostError("REVERT_CONFLICT", "cannot revert a commit without exactly one parent");
+    }
+    const parentOid = parents[0];
+    const parentCommit = await git.readCommit({ fs: fs4__default, dir, oid: parentOid });
+    const before = await treeFileMap(dir, parentCommit.commit.tree);
+    const after = await treeFileMap(dir, target.commit.tree);
+    const allPaths = /* @__PURE__ */ new Set([...before.keys(), ...after.keys()]);
+    const applyParentTree = async () => {
+      for (const fp of allPaths) {
+        const b = before.get(fp);
+        const a = after.get(fp);
+        if (b === a) continue;
+        const abs = path8__default.join(dir, fp);
+        if (!b) {
+          try {
+            await fsp.unlink(abs);
+          } catch {
+          }
+          try {
+            await git.remove({ fs: fs4__default, dir, filepath: fp });
+          } catch {
+          }
+        } else {
+          const { blob } = await git.readBlob({ fs: fs4__default, dir, oid: b });
+          await fsp.mkdir(path8__default.dirname(abs), { recursive: true });
+          await fsp.writeFile(abs, Buffer.from(blob));
+          await git.add({ fs: fs4__default, dir, filepath: fp });
+        }
+      }
+    };
+    await applyParentTree();
+    await stageAll(dir);
+    const newId = await git.commit({
+      fs: fs4__default,
+      dir,
+      message: opts?.message ?? `revert: ${commitId.slice(0, 7)}`,
+      author: DEFAULT_AUTHOR
+    });
+    this.invalidateCount(dir);
+    return { commitId: newId };
+  }
+  async resetTo(dir, commitId, opts) {
+    const createBackup = opts?.createBackupRef !== false;
+    let backupRef;
+    if (createBackup) {
+      try {
+        const head = await git.resolveRef({ fs: fs4__default, dir, ref: "HEAD" });
+        const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        const ref = `refs/backup/${stamp}`;
+        await git.writeRef({ fs: fs4__default, dir, ref, value: head });
+        backupRef = `backup/${stamp}`;
+      } catch {
+      }
+    }
+    await git.branch({
+      fs: fs4__default,
+      dir,
+      ref: "main",
+      object: commitId,
+      force: true,
+      checkout: true
+    });
+    this.invalidateCount(dir);
+    return { backupRef };
+  }
+  async commitCount(dir) {
+    const hit = this.commitCountCache.get(dir);
+    if (hit && Date.now() - hit.at < COMMIT_TTL_MS) {
+      return hit.count;
+    }
+    let count = 0;
+    try {
+      const head = await resolveHead(dir);
+      if (!head) {
+        this.commitCountCache.set(dir, { at: Date.now(), count: 0 });
+        return 0;
+      }
+      const commits = await git.log({ fs: fs4__default, dir, depth: 1e5 });
+      count = commits.length;
+    } catch {
+      count = 0;
+    }
+    this.commitCountCache.set(dir, { at: Date.now(), count });
+    return count;
+  }
+  async log(dir, limit) {
+    try {
+      const commits = await git.log({ fs: fs4__default, dir, depth: Math.max(1, limit) });
+      return commits.map((c) => ({
+        id: c.oid,
+        time: new Date(c.commit.author.timestamp * 1e3).toISOString(),
+        message: c.commit.message.trim().split("\n")[0] ?? ""
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async fileStats(dir, id) {
+    try {
+      const commit = await git.readCommit({ fs: fs4__default, dir, oid: id });
+      const afterMap = await treeFileMap(dir, commit.commit.tree);
+      let beforeMap = /* @__PURE__ */ new Map();
+      const parents = commit.commit.parent ?? [];
+      if (parents.length > 0) {
+        const parent = await git.readCommit({ fs: fs4__default, dir, oid: parents[0] });
+        beforeMap = await treeFileMap(dir, parent.commit.tree);
+      }
+      const paths = /* @__PURE__ */ new Set([...beforeMap.keys(), ...afterMap.keys()]);
+      const out = [];
+      for (const fp of [...paths].sort()) {
+        const bOid = beforeMap.get(fp);
+        const aOid = afterMap.get(fp);
+        if (bOid === aOid) continue;
+        const beforeTxt = bOid ? await readBlobText(dir, bOid) : null;
+        const afterTxt = aOid ? await readBlobText(dir, aOid) : null;
+        if (bOid && beforeTxt === null || aOid && afterTxt === null) {
+          out.push({
+            path: fp,
+            add: aOid ? -1 : 0,
+            del: bOid ? -1 : 0
+          });
+          continue;
+        }
+        out.push({
+          path: fp,
+          ...lineStats(bOid ? beforeTxt : null, aOid ? afterTxt : null)
+        });
+      }
+      return out;
+    } catch {
+      return [];
+    }
+  }
+  async filePreview(dir, id, filepath, maxLines = 18) {
+    try {
+      const commit = await git.readCommit({ fs: fs4__default, dir, oid: id });
+      const afterMap = await treeFileMap(dir, commit.commit.tree);
+      let beforeMap = /* @__PURE__ */ new Map();
+      const parents = commit.commit.parent ?? [];
+      if (parents.length > 0) {
+        const parent = await git.readCommit({ fs: fs4__default, dir, oid: parents[0] });
+        beforeMap = await treeFileMap(dir, parent.commit.tree);
+      }
+      const bOid = beforeMap.get(filepath);
+      const aOid = afterMap.get(filepath);
+      if (!bOid && !aOid) {
+        return "";
+      }
+      const before = bOid ? await readBlobText(dir, bOid) : null;
+      const after = aOid ? await readBlobText(dir, aOid) : null;
+      if (before === null && bOid) {
+        return "";
+      }
+      if (after === null && aOid) {
+        return "";
+      }
+      const diff = unifiedDiff(bOid ? before : null, aOid ? after : null);
+      const changeLines = diff.split("\n").filter((l) => l.startsWith("+") || l.startsWith("-"));
+      const lines = (changeLines.length ? changeLines : diff.split("\n")).filter((l) => l.length > 0);
+      if (lines.length <= maxLines) {
+        return lines.join("\n");
+      }
+      return `${lines.slice(0, maxLines).join("\n")}
+\u2026 (+${lines.length - maxLines})`;
+    } catch {
+      return "";
+    }
+  }
+};
+
+// src/theme-resource.ts
+var EMPTY_THEME_RESOURCE = {
+  runnerCss: () => ""
+};
+
+// src/http/app-runner-html.ts
+function appRunnerHtml(appId, themeCss = "") {
+  const safe = JSON.stringify(appId);
+  const title = appId.replace(/[&<>"']/g, (ch) => {
+    switch (ch) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return "&#39;";
+    }
+  });
+  const themeBlock = themeCss.trim() ? `${themeCss.trim()}
+  ` : "";
+  return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>${title}</title>
+<style>
+  ${themeBlock}html,body,#root{margin:0;height:100%;background:var(--background,#fff);color:var(--foreground,#111);font-family:var(--font-sans,ui-sans-serif,system-ui,sans-serif);}
+  .err{padding:24px;color:#b91c1c;white-space:pre-wrap;}
+  #root.boot{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:14px;}
+  #root.boot .art{position:relative;width:88px;height:72px;color:var(--foreground,#111);}
+  #root.boot .art svg{display:block;width:88px;height:64px;}
+  #root.boot .dots{display:flex;gap:5px;justify-content:center;margin-top:2px;}
+  #root.boot .dots i{width:6px;height:6px;border-radius:50%;background:var(--primary,#2563eb);opacity:.35;animation:mma-dot 1s ease-in-out infinite;}
+  #root.boot .dots i:nth-child(2){animation-delay:.15s;}
+  #root.boot .dots i:nth-child(3){animation-delay:.3s;}
+  @keyframes mma-dot{0%,80%,100%{transform:translateY(0);opacity:.3}40%{transform:translateY(-5px);opacity:1}}
+</style>
+</head>
+<body>
+<div id="root" class="boot" role="status" aria-label="loading">
+  <div class="art" aria-hidden="true">
+    <svg viewBox="0 0 88 64" fill="none">
+      <rect x="10" y="8" width="68" height="48" rx="10" stroke="currentColor" stroke-width="1.6" opacity=".35"/>
+      <rect x="10" y="8" width="68" height="12" rx="10" fill="currentColor" opacity=".08"/>
+      <circle cx="20" cy="14" r="2.2" fill="currentColor" opacity=".35"/>
+      <rect x="26" y="12.2" width="18" height="3.6" rx="1.8" fill="currentColor" opacity=".22"/>
+      <rect x="20" y="28" width="28" height="4" rx="2" fill="currentColor" opacity=".16"/>
+      <rect x="20" y="36" width="40" height="4" rx="2" fill="currentColor" opacity=".1"/>
+      <rect x="20" y="44" width="22" height="4" rx="2" fill="currentColor" opacity=".08"/>
+      <path d="M62 40c6 0 10 5 10 10" stroke="var(--primary,#2563eb)" stroke-width="1.8" stroke-linecap="round" opacity=".85"/>
+      <circle cx="72" cy="50" r="3.2" fill="var(--primary,#2563eb)" opacity=".9"/>
+    </svg>
+    <div class="dots"><i></i><i></i><i></i></div>
+  </div>
+</div>
+<script type="module">
+const APP_ID = ${safe};
+(() => {
+  const q = new URLSearchParams(location.search);
+  const th = q.get("theme") || "light";
+  const pal = q.get("palette") || "default";
+  const dock = q.get("dock") || "fill";
+  document.documentElement.setAttribute("data-theme", th);
+  document.documentElement.classList.toggle("dark", th === "dark");
+  document.documentElement.setAttribute("data-palette", pal);
+  document.documentElement.setAttribute("data-dock", dock);
+  window.addEventListener("message", (ev) => {
+    const d = ev.data;
+    if (!d || d.type !== "mma-set-env") return;
+    if (d.theme) {
+      document.documentElement.setAttribute("data-theme", d.theme);
+      document.documentElement.classList.toggle("dark", d.theme === "dark");
+    }
+    if (d.palette) document.documentElement.setAttribute("data-palette", d.palette);
+    if (d.dock) document.documentElement.setAttribute("data-dock", d.dock);
+  });
+})();
+const cssLink = document.createElement("link");
+cssLink.rel = "stylesheet";
+cssLink.href = "/ui.css";
+document.head.appendChild(cssLink);
+try {
+  await import("/api/app/" + encodeURIComponent(APP_ID) + "/ui/entry.js");
+} catch (e) {
+  const rootEl = document.getElementById("root");
+  if (rootEl) {
+    rootEl.className = "err";
+    rootEl.textContent = String((e && (e.stack || e.message)) || e);
+  }
+}
+</script>
+</body>
+</html>`;
+}
+
+// src/http/http-gateway.ts
+function geistFontPath(name) {
+  for (let dir = resolveUiDistDir(); dir !== path8__default.dirname(dir); dir = path8__default.dirname(dir)) {
+    const fp = path8__default.join(dir, "..", "..", "node_modules", "@fontsource-variable", "geist", "files", name);
+    const p = path8__default.resolve(fp);
+    if (fs4__default.existsSync(p)) return p;
+  }
+  return path8__default.join(resolveUiDistDir(), "..", "..", "node_modules", "@fontsource-variable", "geist", "files", name);
+}
+function listenHttp(server, port) {
+  return new Promise((resolve2, reject) => {
+    const onError = (err) => {
+      server.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      const addr = server.address();
+      resolve2(typeof addr === "object" && addr ? addr.port : port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, "127.0.0.1");
+  });
+}
+function closeHttp(server) {
+  return new Promise((resolve2, reject) => {
+    server.closeAllConnections?.();
+    server.close((err) => {
+      if (err) reject(err);
+      else resolve2();
+    });
+  });
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function publicHostConfig(config, hostPort) {
+  return {
+    theme: config.theme,
+    palette: config.palette,
+    locale: config.locale,
+    chatLanguage: config.chatLanguage,
+    hostPort,
+    llm: config.llm
+  };
+}
+function errorMessage(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+function probePort(port) {
+  return new Promise((resolve2, reject) => {
+    const probe = createServer$1();
+    const onError = (err) => {
+      probe.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      probe.off("error", onError);
+      probe.close((err) => err ? reject(err) : resolve2());
+    };
+    probe.once("error", onError);
+    probe.once("listening", onListening);
+    probe.listen(port, "127.0.0.1");
+  });
+}
+function mergeHostConfigPatch(cur, body) {
+  const theme = typeof body.theme === "string" && THEME_IDS.includes(body.theme) ? body.theme : cur.theme;
+  const palette = typeof body.palette === "string" && body.palette.trim().length > 0 ? body.palette.trim() : cur.palette;
+  const locale = typeof body.locale === "string" && LOCALE_IDS.includes(body.locale) ? body.locale : cur.locale;
+  const chatLanguage = typeof body.chatLanguage === "string" && LOCALE_IDS.includes(body.chatLanguage) ? body.chatLanguage : cur.chatLanguage;
+  let hostPort = cur.hostPort;
+  if (body.hostPort !== void 0) {
+    const n = Number(body.hostPort);
+    if (!Number.isInteger(n) || n < 0 || n > 65535) {
+      throw new HostError("INVALID_HOST_CONFIG", "hostPort must be an integer 0\u201365535");
+    }
+    hostPort = n;
+  }
+  let llm = cur.llm;
+  if (body.llm === null) {
+    llm = null;
+  } else if (isRecord4(body.llm)) {
+    const provider = body.llm.provider;
+    const model = body.llm.model;
+    if (typeof provider !== "string" || !provider.trim() || typeof model !== "string" || !model.trim()) {
+      throw new HostError("INVALID_HOST_CONFIG", "llm requires non-empty provider and model");
+    }
+    llm = { provider: provider.trim(), model: model.trim() };
+  }
+  return {
+    runtimeRoot: cur.runtimeRoot,
+    hostPort,
+    theme,
+    palette,
+    locale,
+    chatLanguage,
+    llm
+  };
+}
+var HttpGateway = class {
+  constructor(apps, config, paths, compiler, git2, themes = EMPTY_THEME_RESOURCE, events, onHostPortChanged) {
+    this.apps = apps;
+    this.config = config;
+    this.paths = paths;
+    this.compiler = compiler;
+    this.git = git2;
+    this.themes = themes;
+    this.events = events;
+    this.onHostPortChanged = onHostPortChanged;
+    this.app = this.buildApp();
+  }
+  apps;
+  config;
+  paths;
+  compiler;
+  git;
+  themes;
+  events;
+  onHostPortChanged;
+  app;
+  server = null;
+  boundPort = 0;
+  get port() {
+    return this.boundPort;
+  }
+  async listen(port) {
+    if (this.server) {
+      return this.boundPort;
+    }
+    const listener = getRequestListener((request, env) => this.app.fetch(request, env));
+    const server = createServer(listener);
+    try {
+      this.boundPort = await listenHttp(server, port);
+      this.server = server;
+    } catch (cause) {
+      server.close();
+      throw new HostError("HOST_LISTEN_FAILED", `failed to listen on ${port}`, { cause });
+    }
+    return this.boundPort;
+  }
+  async close() {
+    const server = this.server;
+    this.server = null;
+    this.boundPort = 0;
+    if (server) {
+      await closeHttp(server);
+    }
+  }
+  buildApp() {
+    const app = new Hono();
+    app.use(
+      "*",
+      cors({
+        origin: "*",
+        allowMethods: ["GET", "POST", "DELETE", "OPTIONS"],
+        allowHeaders: ["content-type"]
+      })
+    );
+    app.onError((err, c) => {
+      if (err instanceof HostError) {
+        return c.json({ ok: false, error: err.message, code: err.code }, 400);
+      }
+      return c.json({ error: errorMessage(err) }, 500);
+    });
+    app.notFound((c) => c.json({ error: "not_found" }, 404));
+    app.get("/health", (c) => c.json({ ok: true, hostPort: this.boundPort }));
+    app.get("/api/events", (c) => {
+      const bus = this.events;
+      if (!bus) {
+        return c.text("events bus unavailable", 503);
+      }
+      const signal = c.req.raw.signal;
+      const stream = new ReadableStream({
+        start(controller) {
+          const enc = new TextEncoder();
+          controller.enqueue(enc.encode("retry: 3000\n\n"));
+          const unsub = bus.subscribe((event) => {
+            try {
+              controller.enqueue(enc.encode(formatSse(event, bus.nextId())));
+            } catch {
+              unsub();
+            }
+          });
+          const onAbort = () => {
+            unsub();
+            try {
+              controller.close();
+            } catch {
+            }
+          };
+          if (signal.aborted) {
+            onAbort();
+            return;
+          }
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+      });
+      return new Response(stream, {
+        headers: {
+          "Content-Type": "text/event-stream; charset=utf-8",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    });
+    app.get(
+      "/api/host-config",
+      (c) => c.json({ ok: true, ...publicHostConfig(this.config, this.boundPort) })
+    );
+    app.post("/api/host-config", async (c) => {
+      let body;
+      try {
+        body = await c.req.json();
+      } catch {
+        return c.json({ ok: false, error: "invalid json" }, 400);
+      }
+      if (!isRecord4(body)) {
+        return c.json({ ok: false, error: "invalid json" }, 400);
+      }
+      let next;
+      try {
+        next = mergeHostConfigPatch(this.config, body);
+      } catch (cause) {
+        if (cause instanceof HostError) {
+          return c.json({ ok: false, error: cause.message, code: cause.code }, 400);
+        }
+        throw cause;
+      }
+      const portChanged = next.hostPort !== this.boundPort && next.hostPort !== 0;
+      if (portChanged) {
+        try {
+          await probePort(next.hostPort);
+        } catch (cause) {
+          return c.json(
+            {
+              ok: false,
+              error: `port in use or bind failed: ${errorMessage(cause)}`,
+              hostPort: this.boundPort,
+              ...publicHostConfig(this.config, this.boundPort)
+            },
+            409
+          );
+        }
+      }
+      Object.assign(this.config, next);
+      writeHostConfig(this.paths, this.config);
+      const responsePort = portChanged ? next.hostPort : this.boundPort;
+      if (portChanged) {
+        const target = next.hostPort;
+        setImmediate(() => {
+          void (async () => {
+            try {
+              await this.close();
+              await this.listen(target);
+              this.onHostPortChanged?.(this.boundPort);
+            } catch (cause) {
+              console.warn("[monkey-mini-app] rebound failed", cause);
+            }
+          })();
+        });
+      }
+      return c.json({ ok: true, ...publicHostConfig(this.config, responsePort) });
+    });
+    app.get("/api/apps", async (c) => {
+      const apps = await this.apps.list();
+      return c.json({ apps });
+    });
+    app.get("/api/palettes", async (c) => {
+      const palettes = await this.themes.listCustomPalettes?.() ?? [];
+      return c.json({ palettes });
+    });
+    app.post("/api/call", async (c) => {
+      let body;
+      try {
+        body = await c.req.json();
+      } catch {
+        return c.json({ ok: false, error: "invalid json" }, 400);
+      }
+      if (!isRecord4(body)) {
+        return c.json({ ok: false, error: "invalid json" }, 400);
+      }
+      const appId = typeof body.appId === "string" ? body.appId : "";
+      const method = typeof body.method === "string" ? body.method : "";
+      if (!appId || !method) {
+        return c.json({ ok: false, error: "missing appId or method" }, 400);
+      }
+      try {
+        const value = await this.apps.call(appId, method, body.args, c.req.raw.signal);
+        return c.json({ ok: true, value });
+      } catch (cause) {
+        return c.json({ ok: false, error: errorMessage(cause) }, 400);
+      }
+    });
+    app.get("/api/apps/:appId/history", async (c) => {
+      const appId = asAppId(c.req.param("appId"));
+      const dir = this.apps.dirOf(appId);
+      const limitRaw = Number(c.req.query("limit"));
+      const limit = Math.min(Number.isFinite(limitRaw) && limitRaw > 0 ? limitRaw : 50, 200);
+      const list = await this.git.log(dir, limit);
+      const commits = await Promise.all(
+        list.map(async (entry) => ({
+          ...entry,
+          files: await this.git.fileStats(dir, entry.id)
+        }))
+      );
+      return c.json({ ok: true, commits });
+    });
+    app.get("/api/apps/:appId/history/:commitId", async (c) => {
+      const appId = asAppId(c.req.param("appId"));
+      const commitId = c.req.param("commitId");
+      const dir = this.apps.dirOf(appId);
+      const stats = await this.git.fileStats(dir, commitId);
+      const log = await this.git.log(dir, 200);
+      const meta = log.find((entry) => entry.id === commitId || entry.id.startsWith(commitId));
+      const files = await Promise.all(
+        stats.map(async (s) => ({
+          ...s,
+          preview: await this.git.filePreview(dir, commitId, s.path)
+        }))
+      );
+      return c.json({
+        ok: true,
+        commit: {
+          id: meta?.id || commitId,
+          time: meta?.time || "",
+          message: meta?.message || "",
+          files
+        }
+      });
+    });
+    app.get("/api/apps/:appId/storage", (c) => {
+      const appId = asAppId(c.req.param("appId"));
+      const dir = path8__default.join(this.apps.dirOf(appId), WorkspacePaths.Rel.storage);
+      return c.json({ ok: true, tables: listStorageTables(dir) });
+    });
+    app.get("/api/apps/:appId/storage/:table", (c) => {
+      const appId = asAppId(c.req.param("appId"));
+      const table = c.req.param("table");
+      const dir = path8__default.join(this.apps.dirOf(appId), WorkspacePaths.Rel.storage);
+      const fp = storageTablePath(dir, table);
+      return c.json({ ok: true, table, value: readJsonFile(fp, null) });
+    });
+    app.get("/api/apps/:appId/theme", (c) => {
+      const appId = asAppId(c.req.param("appId"));
+      const dir = this.apps.dirOf(appId);
+      return c.json({ ok: true, appId, theme: readAppTheme(dir) });
+    });
+    app.post("/api/apps/:appId/theme", async (c) => {
+      const appId = asAppId(c.req.param("appId"));
+      const dir = this.apps.dirOf(appId);
+      let body = {};
+      try {
+        body = await c.req.json();
+      } catch {
+      }
+      const rec = isRecord4(body) ? body : {};
+      const saved = rec.reset ? writeAppTheme(dir, null) : writeAppTheme(dir, {
+        theme: String(rec.theme || "light"),
+        palette: String(rec.palette || "default")
+      });
+      return c.json({ ok: true, appId, theme: saved });
+    });
+    app.delete("/api/app/:appId", async (c) => {
+      const appId = asAppId(c.req.param("appId"));
+      await this.apps.remove(appId);
+      return c.json({ ok: true });
+    });
+    app.get("/", async (c) => {
+      let items = [];
+      try {
+        items = await this.apps.list();
+      } catch {
+        items = [];
+      }
+      const esc = (s) => s.replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[ch]);
+      const cards = items.map((a) => `<a class="card" href="/app/${encodeURIComponent(a.id)}">
+          <div class="mono">${esc(a.acronym || a.name.slice(0, 2).toUpperCase())}</div>
+          <div>
+            <div class="name">${esc(a.name)}</div>
+            <div class="desc">${esc(a.description || a.id)}</div>
+            <div class="meta">${esc(a.id)} \xB7 ${a.commits} commits</div>
+          </div>
+        </a>`).join("\n");
+      const html = `<!doctype html>
+<html><head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>${esc(this.config.theme ?? "monkey-mini-app")} \xB7 \u5C0F\u7A0B\u5E8F</title>
+<link rel="stylesheet" href="/ui.css"/>
+<style>
+  html,body{margin:0;height:100%;background:var(--background,#fff);color:var(--foreground,#111);font-family:var(--font-sans,ui-sans-serif,system-ui,sans-serif);}
+  body{padding:40px;}
+  h1{font-size:1.5rem;margin:0 0 4px;}
+  .sub{color:var(--muted-foreground,#666);margin:0 0 24px;font-size:.9rem;}
+  .grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:14px;max-width:1100px;}
+  .card{display:flex;gap:14px;padding:16px;border:1px solid var(--border,#e2e2e2);border-radius:14px;text-decoration:none;color:inherit;background:var(--card,#fff);transition:border-color .15s, transform .15s;}
+  .card:hover{border-color:var(--primary,#2563eb);transform:translateY(-2px);}
+  .mono{width:48px;height:48px;border-radius:12px;background:var(--muted,#f2f2f2);display:flex;align-items:center;justify-content:center;font-weight:600;color:var(--primary,#2563eb);flex-shrink:0;}
+  .name{font-weight:600;font-size:1rem;}
+  .desc{color:var(--muted-foreground,#666);font-size:.85rem;margin-top:2px;}
+  .meta{color:var(--muted-foreground,#999);font-size:.72rem;margin-top:8px;font-family:monospace;}
+</style>
+</head><body>
+<h1>\u5C0F\u7A0B\u5E8F</h1>
+<p class="sub">\u5171 ${items.length} \u4E2A \xB7 \u70B9\u5F00\u8FDB\u5165</p>
+<div class="grid">${cards}</div>
+</body></html>`;
+      return c.html(html);
+    });
+    app.get("/ui.css", (c) => {
+      try {
+        const css = fs4__default.readFileSync(path8__default.join(resolveUiDistDir(), "globals.css"), "utf8");
+        return c.body(css, 200, { "Content-Type": "text/css; charset=utf-8" });
+      } catch (cause) {
+        return c.text(`ui.css missing: ${errorMessage(cause)}`, 500);
+      }
+    });
+    app.get("/files/:name", (c) => {
+      const name = path8__default.basename(c.req.param("name") || "");
+      try {
+        const p = geistFontPath(name);
+        const buf = fs4__default.readFileSync(p);
+        const ext = path8__default.extname(name).toLowerCase();
+        return c.body(buf, 200, { "Content-Type": ext === ".woff2" ? "font/woff2" : "application/octet-stream" });
+      } catch (cause) {
+        return c.text(`font missing: ${errorMessage(cause)}`, 404);
+      }
+    });
+    app.get("/api/app/:appId/ui/:name", async (c) => {
+      const appId = c.req.param("appId");
+      const name = path8__default.basename(c.req.param("name") || "");
+      if (!name.endsWith(".js")) {
+        return c.json({ error: `bundle file missing: ${name}` }, 404);
+      }
+      let files;
+      try {
+        files = await this.compiler.compile(this.apps.dirOf(appId), {
+          locale: this.config.locale
+        });
+      } catch (cause) {
+        const status = cause instanceof HostError ? 400 : 500;
+        return c.json({ error: errorMessage(cause) }, status);
+      }
+      const file = files.find((f) => f.name === name);
+      if (!file) {
+        return c.json({ error: `bundle file missing: ${name}` }, 404);
+      }
+      return c.body(Buffer.from(file.contents).toString("utf8"), 200, {
+        "Content-Type": "application/javascript; charset=utf-8",
+        "Cache-Control": "no-cache"
+      });
+    });
+    app.get("/app/:appId", (c) => {
+      const html = appRunnerHtml(c.req.param("appId"), this.themes.runnerCss());
+      return c.html(html);
+    });
+    return app;
+  }
+};
+
+// src/tools/tool-facade.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString2(args, key) {
+  const value = args[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new HostError("INVALID_TOOL_ARGS", `missing ${key}`);
+  }
+  return value;
+}
+function asFiles(value) {
+  if (!isRecord5(value)) {
+    throw new HostError("INVALID_TOOL_ARGS", "files must be an object of strings");
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v !== "string") {
+      throw new HostError("INVALID_TOOL_ARGS", `files.${k} must be a string`);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+function asEdits(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new HostError("INVALID_TOOL_ARGS", "edits must be a non-empty array");
+  }
+  return value.map((item, i) => {
+    if (!isRecord5(item)) {
+      throw new HostError("INVALID_TOOL_ARGS", `edits[${i}] must be an object`);
+    }
+    if (typeof item.oldText !== "string" || typeof item.newText !== "string") {
+      throw new HostError("INVALID_TOOL_ARGS", `edits[${i}] requires oldText and newText strings`);
+    }
+    return { oldText: item.oldText, newText: item.newText };
+  });
+}
+function optionalPositiveInt(value, key) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new HostError("INVALID_TOOL_ARGS", `${key} must be an integer`);
+  }
+  return value;
+}
+function parseReadRange(args) {
+  const startLine = optionalPositiveInt(args.startLine, "startLine");
+  const endLine = optionalPositiveInt(args.endLine, "endLine");
+  const offset = optionalPositiveInt(args.offset, "offset");
+  const limit = optionalPositiveInt(args.limit, "limit");
+  const numbered = args.numbered === true ? true : void 0;
+  const start = startLine ?? offset;
+  let end = endLine;
+  if (end === void 0 && start !== void 0 && limit !== void 0) {
+    if (limit < 1) {
+      throw new HostError("INVALID_TOOL_ARGS", "limit must be >= 1");
+    }
+    end = start + limit - 1;
+  } else if (end === void 0 && start === void 0 && limit !== void 0) {
+    if (limit < 1) {
+      throw new HostError("INVALID_TOOL_ARGS", "limit must be >= 1");
+    }
+    return { startLine: 1, endLine: limit, numbered };
+  }
+  if (start === void 0 && end === void 0 && numbered === void 0) {
+    return {};
+  }
+  return { startLine: start, endLine: end, numbered };
+}
+var APP_ID_SCHEMA = { type: "string" };
+function isMiniAppToolName(name) {
+  return name.startsWith("mini_app_");
+}
+var ToolFacade = class {
+  constructor(apps, git2, paths, events) {
+    this.apps = apps;
+    this.git = git2;
+    this.paths = paths;
+    this.events = events;
+  }
+  apps;
+  git;
+  paths;
+  events;
+  definitions() {
+    return [
+      {
+        name: "mini_app_list",
+        description: "List registered monkey-mini-app applications",
+        inputSchema: { type: "object", properties: {} },
+        execute: (args, signal) => this.invoke("mini_app_list", args, signal)
+      },
+      {
+        name: "mini_app_get",
+        description: "Get app manifest summary and absolute directory path",
+        inputSchema: {
+          type: "object",
+          properties: { appId: APP_ID_SCHEMA },
+          required: ["appId"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_get", args, signal)
+      },
+      {
+        name: "mini_app_reload",
+        description: "Validate + sync-compile main.api and ui for an app (replaces mini_app_validate). Returns compile errors if any. On success, auto-commits if the worktree is dirty. Call after a round of edits to verify and warm the UI cache.",
+        inputSchema: {
+          type: "object",
+          properties: { appId: APP_ID_SCHEMA },
+          required: ["appId"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_reload", args, signal)
+      },
+      {
+        name: "mini_app_register",
+        description: "Create a mini-app scaffold under runtime/apps/<appId>/. Prefer this for NEW apps (requires manifest.json). For edits to an existing app, use mini_app_read + mini_app_edit (or mini_app_write). files keys are relative paths (manifest.json, ui.tsx, main.api.ts, lib/..., components/...). No .. or absolute paths.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            files: {
+              type: "object",
+              // dsh-tools requires boolean additionalProperties (not a nested schema).
+              additionalProperties: true,
+              description: "Relative path \u2192 UTF-8 source text (string values). Example keys: manifest.json, ui.tsx, main.api.ts, lib/parse.ts, components/Card.tsx"
+            }
+          },
+          required: ["appId", "files"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_register", args, signal)
+      },
+      {
+        name: "mini_app_list_files",
+        description: "List source files in a mini-app (relative paths + sizes). Skips .git/storage/node_modules.",
+        inputSchema: {
+          type: "object",
+          properties: { appId: APP_ID_SCHEMA },
+          required: ["appId"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_list_files", args, signal)
+      },
+      {
+        name: "mini_app_read",
+        description: "Read one mini-app source file. Optional 1-indexed inclusive line window: startLine/endLine (omit both = whole file; only startLine = to EOF; only endLine = from line 1). Aliases: offset\u2261startLine, limit\u2261line count. Returns { path, content, bytes, totalLines, startLine, endLine, truncated? }. Set numbered:true to prefix lines as N|text (default raw \u2014 better for mini_app_edit).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            path: { type: "string", description: "Relative path e.g. ui.tsx, main.api.ts, lib/x.ts" },
+            startLine: {
+              type: "number",
+              description: "1-indexed start line (inclusive). Omit with endLine for full file."
+            },
+            endLine: {
+              type: "number",
+              description: "1-indexed end line (inclusive). Omit to read through EOF."
+            },
+            offset: {
+              type: "number",
+              description: "Alias of startLine (Pi/Claude style)."
+            },
+            limit: {
+              type: "number",
+              description: "Max lines to read from startLine/offset (alternative to endLine)."
+            },
+            numbered: {
+              type: "boolean",
+              description: "If true, content lines are prefixed with N| (absolute line numbers)."
+            }
+          },
+          required: ["appId", "path"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_read", args, signal)
+      },
+      {
+        name: "mini_app_edit",
+        description: "Surgically edit an existing mini-app file with exact text replacement (Pi-style). Pass edits: [{ oldText, newText }, ...]. Each oldText must match uniquely. Prefer this over mini_app_write for small changes. Default auto-commits; set commit:false to batch then mini_app_reload.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            path: { type: "string" },
+            edits: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  oldText: { type: "string" },
+                  newText: { type: "string" }
+                },
+                required: ["oldText", "newText"]
+              },
+              description: "One or more unique replacements matched against the original file"
+            },
+            commit: {
+              type: "boolean",
+              description: "Auto-commit after edit (default true). Set false to batch changes."
+            }
+          },
+          required: ["appId", "path", "edits"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_edit", args, signal)
+      },
+      {
+        name: "mini_app_write",
+        description: "Create or overwrite one mini-app file with full contents. Use for new files or large rewrites; prefer mini_app_edit for small surgical changes. Default auto-commits; set commit:false to batch.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            path: { type: "string" },
+            content: { type: "string" },
+            commit: { type: "boolean" }
+          },
+          required: ["appId", "path", "content"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_write", args, signal)
+      },
+      {
+        name: "mini_app_delete",
+        description: "Delete one mini-app source file (cannot delete manifest.json). Default auto-commits; set commit:false to batch.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            path: { type: "string" },
+            commit: { type: "boolean" }
+          },
+          required: ["appId", "path"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_delete", args, signal)
+      },
+      {
+        name: "mini_app_open",
+        description: "Open the mini-app in the dsh \u5C0F\u7A0B\u5E8F side panel. The web Host will pop open and focus this app.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            title: { type: "string" }
+          },
+          required: ["appId"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_open", args, signal)
+      },
+      {
+        name: "mini_app_call",
+        description: "Call a mini-app api method. args is a plain object. Do not curl the host HTTP API.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            method: { type: "string" },
+            args: { type: "object" }
+          },
+          required: ["appId", "method"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_call", args, signal)
+      },
+      {
+        name: "mini_app_history_commit",
+        description: "Commit current app working tree (single-branch main)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            message: { type: "string" }
+          },
+          required: ["appId", "message"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_history_commit", args, signal)
+      },
+      {
+        name: "mini_app_history_list",
+        description: "List commit tree (nodes + parentIds, includes backup tips after reset)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            limit: { type: "number" }
+          },
+          required: ["appId"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_history_list", args, signal)
+      },
+      {
+        name: "mini_app_history_reset",
+        description: "Reset main to commitId; creates backup ref; does not delete commits",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            commitId: { type: "string" }
+          },
+          required: ["appId", "commitId"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_history_reset", args, signal)
+      },
+      {
+        name: "mini_app_history_revert",
+        description: "Forward-commit that undoes a past commit (git revert semantics)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            appId: APP_ID_SCHEMA,
+            commitId: { type: "string" }
+          },
+          required: ["appId", "commitId"]
+        },
+        execute: (args, signal) => this.invoke("mini_app_history_revert", args, signal)
+      }
+    ];
+  }
+  async invoke(name, args = {}, signal) {
+    switch (name) {
+      case "mini_app_list":
+        return { apps: await this.apps.list(), runtimeRoot: this.paths.root };
+      case "mini_app_get":
+        return this.handleGet(args);
+      case "mini_app_reload":
+        return this.handleReload(args);
+      case "mini_app_register":
+        return this.handleRegister(args);
+      case "mini_app_list_files":
+        return this.handleListFiles(args);
+      case "mini_app_read":
+        return this.handleRead(args);
+      case "mini_app_edit":
+        return this.handleEdit(args);
+      case "mini_app_write":
+        return this.handleWrite(args);
+      case "mini_app_delete":
+        return this.handleDelete(args);
+      case "mini_app_open":
+        return this.handleOpen(args);
+      case "mini_app_call":
+        return this.handleCall(args, signal);
+      case "mini_app_history_commit":
+        return this.handleHistoryCommit(args);
+      case "mini_app_history_list":
+        return this.handleHistoryList(args);
+      case "mini_app_history_reset":
+        return this.handleHistoryReset(args);
+      case "mini_app_history_revert":
+        return this.handleHistoryRevert(args);
+      default:
+        throw new HostError("UNKNOWN_TOOL", `UNKNOWN_TOOL: ${name}`);
+    }
+  }
+  async handleGet(args) {
+    const appId = requireString2(args, "appId");
+    const app = await this.apps.get(appId);
+    if (!app) {
+      return { ok: false, error: "NOT_FOUND" };
+    }
+    return { ok: true, app, path: this.apps.dirOf(appId) };
+  }
+  async handleReload(args) {
+    const appId = requireString2(args, "appId");
+    return this.apps.reload(appId);
+  }
+  async handleRegister(args) {
+    const appId = requireString2(args, "appId");
+    const files = asFiles(args.files);
+    const app = await this.apps.register(appId, files);
+    return { ok: true, path: this.apps.dirOf(appId), app };
+  }
+  async handleListFiles(args) {
+    const appId = requireString2(args, "appId");
+    const files = await this.apps.listFiles(appId);
+    return { ok: true, appId, files };
+  }
+  async handleRead(args) {
+    const appId = requireString2(args, "appId");
+    const path12 = requireString2(args, "path");
+    const range = parseReadRange(args);
+    try {
+      const file = await this.apps.readFile(appId, path12, range);
+      return { ok: true, ...file };
+    } catch (cause) {
+      if (cause instanceof HostError && cause.code === "INVALID_RANGE") {
+        return { ok: false, error: cause.message, code: cause.code };
+      }
+      throw cause;
+    }
+  }
+  async handleEdit(args) {
+    const appId = requireString2(args, "appId");
+    const path12 = requireString2(args, "path");
+    const edits = asEdits(args.edits);
+    const commit = args.commit === false ? false : void 0;
+    try {
+      const result = await this.apps.editFile(appId, path12, edits, { commit });
+      return { ok: true, ...result };
+    } catch (cause) {
+      if (cause instanceof HostError && cause.code === "EDIT_FAILED") {
+        return { ok: false, error: cause.message, code: cause.code };
+      }
+      throw cause;
+    }
+  }
+  async handleWrite(args) {
+    const appId = requireString2(args, "appId");
+    const path12 = requireString2(args, "path");
+    const content = requireString2(args, "content");
+    const commit = args.commit === false ? false : void 0;
+    const result = await this.apps.writeFile(appId, path12, content, { commit });
+    return { ok: true, ...result };
+  }
+  async handleDelete(args) {
+    const appId = requireString2(args, "appId");
+    const path12 = requireString2(args, "path");
+    const commit = args.commit === false ? false : void 0;
+    const result = await this.apps.deleteFile(appId, path12, { commit });
+    return { ok: true, ...result };
+  }
+  async handleOpen(args) {
+    const appId = requireString2(args, "appId");
+    const app = await this.apps.get(appId);
+    if (!app) {
+      return { ok: false, error: "NOT_FOUND" };
+    }
+    const title = typeof args.title === "string" && args.title ? args.title : app.name;
+    this.events?.emit({ type: "app:open", appId: app.id, title });
+    return { ok: true, appId: app.id, title };
+  }
+  async handleCall(args, signal) {
+    const appId = requireString2(args, "appId");
+    const method = requireString2(args, "method");
+    const callArgs = isRecord5(args.args) ? args.args : args.args === void 0 ? {} : args.args;
+    try {
+      const value = await this.apps.call(appId, method, callArgs, signal);
+      return { ok: true, value };
+    } catch (cause) {
+      if (signal?.aborted) {
+        return { ok: false, error: "cancelled", cancelled: true };
+      }
+      const message = cause instanceof Error ? cause.message : String(cause);
+      return { ok: false, error: message };
+    }
+  }
+  async handleHistoryCommit(args) {
+    const appId = requireString2(args, "appId");
+    const message = requireString2(args, "message");
+    const dir = this.apps.dirOf(appId);
+    await this.git.init(dir);
+    return this.git.commit(dir, message);
+  }
+  async handleHistoryList(args) {
+    const appId = requireString2(args, "appId");
+    const limit = typeof args.limit === "number" ? args.limit : void 0;
+    const dir = this.apps.dirOf(appId);
+    await this.git.init(dir);
+    return this.git.listCommits(dir, { limit });
+  }
+  async handleHistoryReset(args) {
+    const appId = requireString2(args, "appId");
+    const commitId = requireString2(args, "commitId");
+    const dir = this.apps.dirOf(appId);
+    await this.git.init(dir);
+    return this.git.resetTo(dir, commitId);
+  }
+  async handleHistoryRevert(args) {
+    const appId = requireString2(args, "appId");
+    const commitId = requireString2(args, "commitId");
+    const dir = this.apps.dirOf(appId);
+    await this.git.init(dir);
+    return this.git.revert(dir, commitId);
+  }
+};
+
+// src/host.ts
+var Host = class {
+  constructor(capabilities, lifecycle, paths, config, services, http) {
+    this.capabilities = capabilities;
+    this.lifecycle = lifecycle;
+    this.paths = paths;
+    this.config = config;
+    this.services = services;
+    this.http = http;
+  }
+  capabilities;
+  lifecycle;
+  paths;
+  config;
+  services;
+  http;
+  boundPort = 0;
+  attached = false;
+  active = false;
+  get port() {
+    return this.boundPort;
+  }
+  async apply(ctx) {
+    if (!this.attached) {
+      await this.lifecycle.attach(ctx, this.services);
+      this.attached = true;
+    }
+    return this.start();
+  }
+  async start() {
+    this.active = true;
+    if (this.boundPort > 0) {
+      return { port: this.boundPort };
+    }
+    try {
+      this.boundPort = await this.http.listen(this.config.hostPort);
+    } catch (cause) {
+      if (cause instanceof HostError) {
+        throw cause;
+      }
+      throw new HostError(
+        "HOST_LISTEN_FAILED",
+        `failed to listen on ${this.config.hostPort}`,
+        { cause }
+      );
+    }
+    this.lifecycle.onHostPortChanged?.(this.boundPort);
+    return { port: this.boundPort };
+  }
+  async stop() {
+    if (!this.active && this.boundPort === 0 && !this.attached) {
+      return;
+    }
+    this.active = false;
+    this.boundPort = 0;
+    try {
+      await this.http.close();
+    } finally {
+      const detach = this.lifecycle.detach;
+      this.attached = false;
+      if (detach) {
+        await detach();
+      }
+    }
+  }
+};
+
+// src/create-host.ts
+function createHost(capabilities, lifecycle, options) {
+  const config = parseHostConfig(options.config);
+  const paths = new WorkspacePaths(config.runtimeRoot);
+  const git2 = new GitHistory();
+  const apps = new AppsManager(paths, capabilities, git2, config);
+  const events = new HostEventBus();
+  const tools = new ToolFacade(apps, git2, paths, events);
+  const compiler = new UiCompiler(paths);
+  apps.setUiCompiler(compiler);
+  const themes = options.themes ?? EMPTY_THEME_RESOURCE;
+  const http = new HttpGateway(
+    apps,
+    config,
+    paths,
+    compiler,
+    git2,
+    themes,
+    events,
+    (port) => lifecycle.onHostPortChanged?.(port)
+  );
+  const services = { apps, git: git2, tools, paths, config };
+  return new Host(capabilities, lifecycle, paths, config, services, http);
+}
+
+// src/locales/en.json
+var en_default = {
+  config: {
+    missingFile: "Host config file not found: {{path}}",
+    missingHint: "Run the install script or mma init to create host.json."
+  }
+};
+
+// src/locales/zh-CN.json
+var zh_CN_default = {
+  config: {
+    missingFile: "\u672A\u627E\u5230 host \u914D\u7F6E\u6587\u4EF6\uFF1A{{path}}",
+    missingHint: "\u8BF7\u5148\u8FD0\u884C\u5B89\u88C5\u811A\u672C\u6216 mma init \u751F\u6210 host.json\u3002"
+  }
+};
+
+// src/i18n/index.ts
+var resources = {
+  "zh-CN": { translation: zh_CN_default },
+  en: { translation: en_default }
+};
+function isLocaleId(value) {
+  return LOCALE_IDS.includes(value);
+}
+function failOnMissingKey() {
+  return process.env.NODE_ENV !== "production";
+}
+function createHostI18n(locale) {
+  if (!isLocaleId(locale)) {
+    throw new HostError("I18N_INVALID_LOCALE", `unsupported locale: ${String(locale)}`);
+  }
+  const i18n = createInstance();
+  void i18n.init({
+    lng: locale,
+    fallbackLng: false,
+    supportedLngs: LOCALE_IDS,
+    nonExplicitSupportedLngs: false,
+    load: "currentOnly",
+    defaultNS: "translation",
+    ns: ["translation"],
+    resources,
+    interpolation: { escapeValue: false },
+    returnNull: false,
+    returnEmptyString: false,
+    initImmediate: false,
+    showSupportNotice: false
+  });
+  if (!i18n.isInitialized) {
+    throw new HostError("I18N_INIT_FAILED", `i18n failed to initialize for locale: ${locale}`);
+  }
+  return {
+    locale,
+    t(key, params) {
+      if (!i18n.exists(key)) {
+        if (failOnMissingKey()) {
+          throw new HostError("I18N_MISSING_KEY", `missing i18n key: ${key}`);
+        }
+        return key;
+      }
+      const value = i18n.t(key, params ?? {});
+      if (typeof value !== "string") {
+        throw new HostError("I18N_INVALID_VALUE", `i18n key did not resolve to a string: ${key}`);
+      }
+      return value;
+    }
+  };
+}
+
+// src/index.ts
+var packageName = "@monkey-mini-app/host";
+
+export { AppsManager, DEFAULT_HOST_CONFIG_SEED, EMPTY_THEME_RESOURCE, GitHistory, Host, HostConfigError, HostError, HostEventBus, HttpGateway, LOCALE_IDS, PALETTE_IDS, THEME_IDS, ToolFacade, UiCompiler, WorkspacePaths, acronymOf, appRunnerHtml, applyEditsToNormalizedContent, asAbsolutePath, asAppId, assertNever, bindCapsToContext, bootstrapHostConfig, createHost, createHostI18n, effectiveSignal, formatSse, fuzzyFindText, isAbsolutePath, isAgentCwdType, isAppId, isMiniAppToolName, listStorageTables, loadHostConfig, packageName, parseHostConfig, parseManifest, readAppTheme, readJsonFile, resolveAgentCwd, resolveUiDistDir, storageTablePath, writeAppTheme, writeHostConfig };