codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/grant-guard.js

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var grant_guard_exports = {};
+__export(grant_guard_exports, {
+  grantChange: () => grantChange,
+  grantRefusal: () => grantRefusal,
+  httpGrantsAllowed: () => httpGrantsAllowed
+});
+module.exports = __toCommonJS(grant_guard_exports);
+const GRANT_FIELDS = [
+  ["mcp", "capabilities", "Settings \u2192 MCP Server"],
+  ["mcp", "projectScope", "Settings \u2192 MCP Server"],
+  // Who may change things over plain HTTP (carried item 2b). Otherwise a
+  // script refused a change could turn changes back on and try again.
+  ["mcp", "acceptLocalApiChanges", "Settings \u2192 MCP Server \u2192 Local API"],
+  ["device", "exposeMobileApi", "Settings \u2192 Devices"],
+  ["device", "advertise", "Settings \u2192 Devices"],
+  ["device", "shareAudio", "Settings \u2192 Devices"],
+  ["webhooks", "allowedHosts", "Settings \u2192 Plans"],
+  ["webhooks", "allowLoopback", "Settings \u2192 Plans"],
+  // How long the record is kept (B10.2): shortening it erases evidence, so
+  // no agent or script may, only the person.
+  ["data", "retentionDays", "Settings \u2192 Data"],
+  // Keeping remotes current (E5) has the app reach hosts on its own, on a
+  // timer: what it can reach widens, so only the person turns it on.
+  ["git", "keepRemotesCurrent", "Settings \u2192 Git"]
+];
+function httpGrantsAllowed() {
+  return process.env.NODE_ENV === "test" && process.env.CODETRELLIS_ALLOW_HTTP_GRANTS === "1";
+}
+function grantChange(patch, current) {
+  if (!patch || typeof patch !== "object") return null;
+  const p = patch;
+  for (const [section, key, where] of GRANT_FIELDS) {
+    const next = p[section]?.[key];
+    if (next === void 0) continue;
+    const now = current[section]?.[key];
+    if (JSON.stringify(next) !== JSON.stringify(now ?? (Array.isArray(next) ? [] : void 0))) {
+      return { field: `${section}.${key}`, where };
+    }
+  }
+  return null;
+}
+function grantRefusal(field, where) {
+  return `Only you can change ${field} \u2014 in the CodeTrellis app, ${where}.`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  grantChange,
+  grantRefusal,
+  httpGrantsAllowed
+});

package/src/backend/services/html-view-policy.js

@@ -0,0 +1,135 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var html_view_policy_exports = {};
+__export(html_view_policy_exports, {
+  htmlAssetType: () => htmlAssetType,
+  htmlViewCsp: () => htmlViewCsp,
+  isSameReport: () => isSameReport,
+  reportAssetPath: () => reportAssetPath,
+  serveReportFile: () => serveReportFile
+});
+module.exports = __toCommonJS(html_view_policy_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_confined_fs = require("./confined-fs");
+const ASSET_TYPES = {
+  html: "text/html; charset=utf-8",
+  htm: "text/html; charset=utf-8",
+  css: "text/css; charset=utf-8",
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  json: "application/json",
+  txt: "text/plain; charset=utf-8",
+  map: "application/json",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  mp4: "video/mp4",
+  webm: "video/webm"
+};
+function htmlAssetType(rel) {
+  return ASSET_TYPES[import_node_path.default.extname(rel).slice(1).toLowerCase()] ?? null;
+}
+function reportAssetPath(reportRel, urlPath) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(urlPath);
+  } catch {
+    return null;
+  }
+  if (decoded.includes("\0") || decoded.includes("\\")) return null;
+  const folder = import_node_path.default.posix.dirname(reportRel.split(import_node_path.default.sep).join("/"));
+  const wanted = decoded.replace(/^\/+/, "") || import_node_path.default.posix.basename(reportRel);
+  const rel = import_node_path.default.posix.normalize(import_node_path.default.posix.join(folder, wanted));
+  if (rel === ".." || rel.startsWith("../") || import_node_path.default.posix.isAbsolute(rel)) return null;
+  if (folder !== "." && !rel.startsWith(`${folder}/`)) return null;
+  return rel;
+}
+function htmlViewCsp(scripts) {
+  return [
+    "default-src 'none'",
+    "img-src ct-html: data: blob:",
+    "style-src ct-html: 'unsafe-inline'",
+    "font-src ct-html: data:",
+    "media-src ct-html: data: blob:",
+    scripts ? "script-src ct-html: 'unsafe-inline'" : "script-src 'none'",
+    scripts ? "worker-src blob: ct-html:" : "worker-src 'none'",
+    "frame-src 'none'",
+    "object-src 'none'",
+    "form-action 'none'",
+    "base-uri 'none'"
+  ].join("; ");
+}
+function isSameReport(current, target) {
+  try {
+    const a = new URL(current);
+    const b = new URL(target);
+    return a.protocol === "ct-html:" && b.protocol === "ct-html:" && a.host === b.host;
+  } catch {
+    return false;
+  }
+}
+function serveReportFile(report, urlPath, scripts) {
+  const notFound = { status: 404, headers: {}, stream: null, error: "Not part of this report" };
+  if (!/\.html?$/i.test(report.rel)) return notFound;
+  const rel = reportAssetPath(report.rel, urlPath);
+  const type = rel ? htmlAssetType(rel) : null;
+  if (!rel || !type) return notFound;
+  let opened;
+  try {
+    opened = (0, import_confined_fs.openReadStreamWithin)(report.root, rel, {}, "report file");
+  } catch {
+    return notFound;
+  }
+  return {
+    status: 200,
+    stream: opened.stream,
+    headers: {
+      "Content-Type": type,
+      "Content-Length": String(opened.size),
+      "X-Content-Type-Options": "nosniff",
+      "Cache-Control": "no-store",
+      "Content-Security-Policy": htmlViewCsp(scripts)
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  htmlAssetType,
+  htmlViewCsp,
+  isSameReport,
+  reportAssetPath,
+  serveReportFile
+});

package/src/backend/services/human-decision.js

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var human_decision_exports = {};
+__export(human_decision_exports, {
+  actorTypeOf: () => actorTypeOf,
+  isHumanDecision: () => isHumanDecision,
+  isUnverifiedDecision: () => isUnverifiedDecision,
+  issueHumanDecision: () => issueHumanDecision,
+  issueUnverifiedDecision: () => issueUnverifiedDecision
+});
+module.exports = __toCommonJS(human_decision_exports);
+const issued = /* @__PURE__ */ new WeakSet();
+function issueHumanDecision(channel, actor, device = null) {
+  const decision = Object.freeze({ actor, channel, device });
+  issued.add(decision);
+  return decision;
+}
+function isHumanDecision(value) {
+  return typeof value === "object" && value !== null && issued.has(value);
+}
+const unverified = /* @__PURE__ */ new WeakSet();
+function issueUnverifiedDecision(actor) {
+  const decision = Object.freeze({ actor, channel: "local-api", device: null });
+  unverified.add(decision);
+  return decision;
+}
+function isUnverifiedDecision(value) {
+  return typeof value === "object" && value !== null && unverified.has(value);
+}
+function actorTypeOf(decision) {
+  return isHumanDecision(decision) ? "human" : "unverified";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  actorTypeOf,
+  isHumanDecision,
+  isUnverifiedDecision,
+  issueHumanDecision,
+  issueUnverifiedDecision
+});

package/src/backend/services/importers.js

@@ -0,0 +1,159 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var importers_exports = {};
+__export(importers_exports, {
+  exportedNames: () => exportedNames,
+  exportedSymbols: () => exportedSymbols,
+  importersOf: () => importersOf,
+  originsOf: () => originsOf
+});
+module.exports = __toCommonJS(importers_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_database = require("./database");
+const MAX_DEPTH = 5;
+const isGo = (file) => /\.go$/.test(file) && !/_test\.go$/.test(file);
+function rowsImporting(target) {
+  const go = isGo(target);
+  const dir = import_node_path.default.dirname(target);
+  const res = go ? (0, import_database.getDb)().exec(
+    `SELECT f.path, f.relative_path, i.specifiers, i.is_namespace, i.is_reexport, i.resolved_path
+         FROM imports i JOIN files f ON i.file_id = f.id
+        WHERE i.resolved_path LIKE ? ESCAPE '\\'`,
+    [`${dir.replace(/[\\%_]/g, (c) => `\\${c}`)}${import_node_path.default.sep}%.go`]
+  ) : (0, import_database.getDb)().exec(
+    `SELECT f.path, f.relative_path, i.specifiers, i.is_namespace, i.is_reexport
+         FROM imports i JOIN files f ON i.file_id = f.id
+        WHERE i.resolved_path = ?`,
+    [target]
+  );
+  const rows = (res[0]?.values ?? []).filter((r) => !go || import_node_path.default.dirname(r[5]) === dir && isGo(r[5]));
+  if (go) {
+    return rows.map((r) => ({ path: r[0], rel: r[1], specifiers: [], namespace: true, reexport: false }));
+  }
+  return rows.map((r) => ({
+    path: r[0],
+    rel: r[1],
+    specifiers: JSON.parse(r[2] || "[]"),
+    namespace: r[3] === 1,
+    reexport: r[4] === 1
+  }));
+}
+function exportedNames(filePath) {
+  const res = (0, import_database.getDb)().exec(
+    `SELECT s.name, s.modifiers, f.language FROM symbols s JOIN files f ON s.file_id = f.id
+      WHERE f.path = ? AND s.parent_symbol_id IS NULL`,
+    [filePath]
+  );
+  const out = /* @__PURE__ */ new Set();
+  for (const [name, mods, lang] of res[0]?.values ?? []) {
+    const modifiers = JSON.parse(mods || "[]");
+    if (modifiers.includes("export") || lang === "python" && !name.startsWith("_")) out.add(name);
+  }
+  return out;
+}
+function exportedSymbols() {
+  const res = (0, import_database.getDb)().exec(
+    `SELECT f.path, f.relative_path, s.name, s.modifiers, f.language FROM symbols s JOIN files f ON s.file_id = f.id
+      WHERE s.parent_symbol_id IS NULL`
+  );
+  const out = [];
+  for (const [p, rel, name, mods, lang] of res[0]?.values ?? []) {
+    const modifiers = JSON.parse(mods || "[]");
+    if (modifiers.includes("export") || lang === "python" && !name.startsWith("_")) out.push({ path: p, rel, name });
+  }
+  return out;
+}
+function stored(filePath) {
+  const row = (0, import_database.getDb)().exec(
+    `SELECT path FROM files WHERE path = ? OR relative_path = ? LIMIT 1`,
+    [filePath, filePath.replace(/^\.\//, "")]
+  );
+  return row[0]?.values[0]?.[0] ?? filePath;
+}
+function importersOf(filePath, names) {
+  const target = stored(filePath);
+  const found = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (file, wanted, via) => {
+    const key = `${file}\0${[...wanted ?? ["*"]].sort().join(",")}`;
+    if (seen.has(key) || via.length > MAX_DEPTH) return;
+    seen.add(key);
+    const offered = wanted ?? exportedNames(file);
+    const narrow = wanted !== null || offered.size > 0;
+    for (const row of rowsImporting(file)) {
+      if (row.path === target) continue;
+      if (row.reexport) {
+        const star = row.specifiers.includes("*");
+        const passed = row.namespace && !star ? null : new Set([...offered].filter((n) => star || row.specifiers.includes(n)));
+        if (passed === null || passed.size > 0 || !narrow) visit(row.path, passed, [row.rel, ...via]);
+        continue;
+      }
+      const direct = via.length === 0 && wanted === null;
+      const uses = row.namespace ? [...offered] : row.specifiers.filter((s) => !narrow || offered.has(s));
+      if (!direct && !row.namespace && uses.length === 0) continue;
+      const entry = {
+        path: row.path,
+        relativePath: row.rel,
+        names: direct && !row.namespace ? row.specifiers : uses,
+        possibly: row.namespace,
+        via: [...via]
+      };
+      const had = found.get(row.path);
+      if (!had || had.via.length > entry.via.length) found.set(row.path, entry);
+    }
+  };
+  visit(target, names ? new Set(names) : null, []);
+  return [...found.values()].sort((a, b) => a.via.length - b.via.length || a.relativePath.localeCompare(b.relativePath));
+}
+function originsOf(filePath, name) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (file, depth) => {
+    if (seen.has(file) || depth > MAX_DEPTH) return;
+    seen.add(file);
+    out.push(file);
+    const res = (0, import_database.getDb)().exec(
+      `SELECT i.resolved_path, i.specifiers FROM imports i JOIN files f ON i.file_id = f.id
+        WHERE f.path = ? AND i.is_reexport = 1 AND i.resolved_path IS NOT NULL`,
+      [file]
+    );
+    for (const [resolved, specs] of res[0]?.values ?? []) {
+      const names = JSON.parse(specs || "[]");
+      if (name === "*" || names.includes(name) || names.includes("*")) visit(resolved, depth + 1);
+    }
+  };
+  visit(stored(filePath), 0);
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportedNames,
+  exportedSymbols,
+  importersOf,
+  originsOf
+});

package/src/backend/services/intent-service.js

@@ -0,0 +1,105 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var intent_service_exports = {};
+__export(intent_service_exports, {
+  MAX_INTENT_PATHS: () => MAX_INTENT_PATHS,
+  MAX_INTENT_SUMMARY: () => MAX_INTENT_SUMMARY,
+  MAX_INTENT_SYMBOLS: () => MAX_INTENT_SYMBOLS,
+  clearAllIntents: () => clearAllIntents,
+  clearIntent: () => clearIntent,
+  declareIntent: () => declareIntent,
+  getIntent: () => getIntent,
+  intentFiles: () => intentFiles,
+  normaliseIntentPath: () => normaliseIntentPath,
+  parseIntentSymbol: () => parseIntentSymbol
+});
+module.exports = __toCommonJS(intent_service_exports);
+var import_node_path = __toESM(require("node:path"));
+const MAX_INTENT_PATHS = 50;
+const MAX_INTENT_SYMBOLS = 50;
+const MAX_INTENT_SUMMARY = 500;
+const intents = /* @__PURE__ */ new Map();
+function normaliseIntentPath(raw, roots) {
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed.includes("\0")) return null;
+  let rel = trimmed;
+  if (import_node_path.default.isAbsolute(trimmed)) {
+    const inside = roots.map((r) => import_node_path.default.relative(r, trimmed)).find((r) => r && !r.startsWith("..") && !import_node_path.default.isAbsolute(r));
+    if (!inside) return null;
+    rel = inside;
+  }
+  const norm = import_node_path.default.posix.normalize(rel.split(import_node_path.default.sep).join("/")).replace(/^\.\//, "");
+  if (!norm || norm === "." || norm.startsWith("../") || norm === ".." || norm.startsWith("/")) return null;
+  return norm;
+}
+function parseIntentSymbol(raw, roots) {
+  const at = raw.lastIndexOf("#");
+  const name = (at >= 0 ? raw.slice(at + 1) : raw).trim();
+  if (!/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(name)) return null;
+  if (at < 0) return { path: null, name };
+  const p = normaliseIntentPath(raw.slice(0, at), roots);
+  return p ? { path: p, name } : null;
+}
+function intentFiles(intent) {
+  const bare = intent.symbols.filter((s) => !s.includes("#"));
+  const files = /* @__PURE__ */ new Map();
+  for (const p of intent.paths) files.set(p, new Set(bare));
+  for (const s of intent.symbols) {
+    const at = s.lastIndexOf("#");
+    if (at < 0) continue;
+    const p = s.slice(0, at);
+    if (!files.has(p)) files.set(p, /* @__PURE__ */ new Set());
+    files.get(p).add(s.slice(at + 1));
+  }
+  return [...files].map(([p, names]) => ({ path: p, symbols: [...names].sort() })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function declareIntent(intent) {
+  intents.set(intent.sessionId, intent);
+}
+function getIntent(sessionId) {
+  return intents.get(sessionId) ?? null;
+}
+function clearIntent(sessionId) {
+  return intents.delete(sessionId);
+}
+function clearAllIntents() {
+  intents.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_INTENT_PATHS,
+  MAX_INTENT_SUMMARY,
+  MAX_INTENT_SYMBOLS,
+  clearAllIntents,
+  clearIntent,
+  declareIntent,
+  getIntent,
+  intentFiles,
+  normaliseIntentPath,
+  parseIntentSymbol
+});

package/src/backend/services/ipc-dispatcher.js

@@ -0,0 +1,164 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ipc_dispatcher_exports = {};
+__export(ipc_dispatcher_exports, {
+  cameFromAppWindow: () => cameFromAppWindow,
+  dispatch: () => dispatch,
+  dispatchAuthorised: () => dispatchAuthorised
+});
+module.exports = __toCommonJS(ipc_dispatcher_exports);
+var import_node_net = require("node:net");
+var import_node_http = require("node:http");
+var import_capability_token = require("./capability-token");
+function dispatchAuthorised(app, req) {
+  return run(app, {
+    ...req,
+    headers: {
+      ...req.headers ?? {},
+      // Last, deliberately: a caller cannot override it with a wrong value.
+      [import_capability_token.TOKEN_HEADER]: (0, import_capability_token.getCapabilityToken)()
+    }
+  }, true);
+}
+const appWindowRequests = /* @__PURE__ */ new WeakSet();
+function cameFromAppWindow(req) {
+  return appWindowRequests.has(req);
+}
+function dispatch(app, req) {
+  return run(app, req, false);
+}
+function run(app, req, fromAppWindow) {
+  return new Promise((resolve) => {
+    const fakeReq = buildFakeRequest(req);
+    if (fromAppWindow) appWindowRequests.add(fakeReq);
+    const fakeRes = buildFakeResponse(fakeReq, (response) => resolve(response));
+    try {
+      app(fakeReq, fakeRes);
+    } catch (err) {
+      if (!fakeRes.writableEnded) {
+        resolve({
+          status: 500,
+          headers: { "content-type": "text/plain; charset=utf-8" },
+          body: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  });
+}
+function buildFakeRequest(input) {
+  const fakeSocket = new import_node_net.Socket();
+  fakeSocket._handle = null;
+  const req = new import_node_http.IncomingMessage(fakeSocket);
+  req.method = (input.method || "GET").toUpperCase();
+  req.url = input.url;
+  const headers = {};
+  for (const [k, v] of Object.entries(input.headers ?? {})) {
+    headers[k.toLowerCase()] = v;
+  }
+  let bodyBuf = null;
+  if (input.body != null) {
+    bodyBuf = typeof input.body === "string" ? Buffer.from(input.body, "utf-8") : Buffer.from(input.body);
+    if (!("content-length" in headers)) {
+      headers["content-length"] = String(bodyBuf.length);
+    }
+    if (!("content-type" in headers)) {
+      headers["content-type"] = "application/json; charset=utf-8";
+    }
+  }
+  req.headers = headers;
+  req.rawHeaders = Object.entries(headers).flatMap(([k, v]) => [k, v]);
+  req.complete = false;
+  process.nextTick(() => {
+    if (bodyBuf) req.push(bodyBuf);
+    req.push(null);
+    req.complete = true;
+  });
+  return req;
+}
+function buildFakeResponse(req, done) {
+  const res = new import_node_http.ServerResponse(req);
+  res.__chunks = [];
+  res.__statusCode = 200;
+  res.__headers = {};
+  res.__finished = false;
+  const origSetHeader = res.setHeader.bind(res);
+  res.setHeader = (name, value) => {
+    res.__headers[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+    return origSetHeader(name, value);
+  };
+  res.removeHeader = (name) => {
+    delete res.__headers[name.toLowerCase()];
+  };
+  res.writeHead = function writeHead(status, arg2, arg3) {
+    res.__statusCode = status;
+    res.statusCode = status;
+    const headerArg = typeof arg2 === "object" ? arg2 : arg3;
+    if (headerArg) {
+      for (const [k, v] of Object.entries(headerArg)) {
+        const value = Array.isArray(v) ? v.join(", ") : String(v);
+        res.__headers[k.toLowerCase()] = value;
+      }
+    }
+    return res;
+  };
+  res.write = function write(chunk) {
+    if (chunk != null) {
+      res.__chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return true;
+  };
+  res.end = function end(chunk) {
+    if (res.__finished) return res;
+    if (chunk != null && typeof chunk !== "function") {
+      res.__chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    res.__finished = true;
+    try {
+      Object.defineProperty(res, "writableEnded", { value: true, writable: true, configurable: true });
+    } catch {
+    }
+    try {
+      Object.defineProperty(res, "finished", { value: true, writable: true, configurable: true });
+    } catch {
+    }
+    try {
+      Object.defineProperty(res, "headersSent", { value: true, writable: true, configurable: true });
+    } catch {
+    }
+    res.__statusCode = res.statusCode || res.__statusCode || 200;
+    for (const name of res.getHeaderNames()) {
+      const v = res.getHeader(name);
+      if (v != null && !(name.toLowerCase() in res.__headers)) {
+        res.__headers[name.toLowerCase()] = Array.isArray(v) ? v.join(", ") : String(v);
+      }
+    }
+    done({
+      status: res.__statusCode,
+      headers: res.__headers,
+      body: Buffer.concat(res.__chunks).toString("utf-8")
+    });
+    return res;
+  };
+  return res;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cameFromAppWindow,
+  dispatch,
+  dispatchAuthorised
+});