@rubytech/create-maxy-code 0.1.51 → 0.1.58

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/lib/neo4j.ts

@@ -0,0 +1,47 @@
+import neo4j, { Driver, Session } from "neo4j-driver";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+let driver: Driver | null = null;
+
+function readPassword(): string {
+  if (process.env.NEO4J_PASSWORD) return process.env.NEO4J_PASSWORD;
+  const passwordFile = resolve(
+    process.env.PLATFORM_ROOT ?? resolve(import.meta.dirname, "../../../.."),
+    "config/.neo4j-password",
+  );
+  try {
+    return readFileSync(passwordFile, "utf-8").trim();
+  } catch {
+    throw new Error(
+      `Neo4j password not found. Expected at ${passwordFile} or in NEO4J_PASSWORD env var.`,
+    );
+  }
+}
+
+export function getDriver(): Driver {
+  if (!driver) {
+    const uri = process.env.NEO4J_URI;
+    if (!uri) {
+      throw new Error(
+        "[property-data] NEO4J_URI unset — refusing to default to bolt://localhost:7687",
+      );
+    }
+    const user = process.env.NEO4J_USER ?? "neo4j";
+    const password = readPassword();
+    console.error(`[property-data] resolved neo4j_uri=${uri}`);
+    driver = neo4j.driver(uri, neo4j.auth.basic(user, password));
+  }
+  return driver;
+}
+
+export function getSession(): Session {
+  return getDriver().session();
+}
+
+export async function closeDriver(): Promise<void> {
+  if (driver) {
+    await driver.close();
+    driver = null;
+  }
+}

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/lib/propertydata-api.ts

@@ -0,0 +1,135 @@
+import { getSession } from "./neo4j.js";
+import { decrypt } from "./crypto.js";
+
+// PropertyData API V1 client. Every endpoint is a GET against
+// https://api.propertydata.co.uk/<endpoint> with `key=<api-key>` plus
+// endpoint-specific query params. Response envelope:
+//
+//   { "status": "success", ...payload }
+//   { "status": "error", "message": "..." }
+//
+// The `propertyDataCall` helper returns either the parsed payload as a
+// JSON string ready for tool text content, or throws PropertyDataError /
+// KeyNotRegisteredError so the tool wrapper can produce a deterministic
+// error envelope.
+
+const BASE_URL = "https://api.propertydata.co.uk";
+const REQUEST_TIMEOUT_MS = 15_000;
+
+export class KeyNotRegisteredError extends Error {
+  constructor() {
+    super("key-not-registered");
+    this.name = "KeyNotRegisteredError";
+  }
+}
+
+export class PropertyDataError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly endpoint: string,
+    public readonly upstreamMessage: string,
+  ) {
+    super(`http-${status} from PropertyData endpoint=${endpoint}: ${upstreamMessage}`);
+    this.name = "PropertyDataError";
+  }
+}
+
+export class BadResponseError extends Error {
+  constructor(public readonly endpoint: string, public readonly length: number) {
+    super(`bad-response from PropertyData endpoint=${endpoint} (non-JSON, length=${length})`);
+    this.name = "BadResponseError";
+  }
+}
+
+export interface PropertyDataKey {
+  encryptedKey: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export async function loadAccountKey(accountId: string): Promise<PropertyDataKey | null> {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (k:PropertyDataKey {accountId: $accountId})
+       RETURN k.encryptedKey AS encryptedKey,
+              k.createdAt AS createdAt,
+              k.updatedAt AS updatedAt`,
+      { accountId },
+    );
+    if (result.records.length === 0) return null;
+    const r = result.records[0];
+    return {
+      encryptedKey: r.get("encryptedKey"),
+      createdAt: r.get("createdAt") ?? "",
+      updatedAt: r.get("updatedAt") ?? "",
+    };
+  } finally {
+    await session.close();
+  }
+}
+
+export async function resolveAccountApiKey(accountId: string): Promise<string> {
+  const stored = await loadAccountKey(accountId);
+  if (!stored) throw new KeyNotRegisteredError();
+  return decrypt(stored.encryptedKey);
+}
+
+export interface CallOptions {
+  endpoint: string;
+  toolName: string;
+  accountId: string;
+  params: Record<string, string | number | undefined>;
+}
+
+export async function propertyDataCall(opts: CallOptions): Promise<string> {
+  const { endpoint, toolName, accountId, params } = opts;
+  const apiKey = await resolveAccountApiKey(accountId);
+
+  const search = new URLSearchParams();
+  search.set("key", apiKey);
+  for (const [k, v] of Object.entries(params)) {
+    if (v === undefined || v === null || v === "") continue;
+    search.set(k, String(v));
+  }
+  const url = `${BASE_URL}/${endpoint}?${search.toString()}`;
+
+  const postcode = params.postcode ?? "";
+  const start = Date.now();
+  const response = await fetch(url, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  });
+  const ms = Date.now() - start;
+
+  const statusTag = response.ok ? "ok" : `http-${Math.floor(response.status / 100)}xx`;
+  console.error(
+    `[property-data] tool=${toolName} account=${accountId} postcode=${postcode} status=${statusTag} ms=${ms}`,
+  );
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new PropertyDataError(response.status, endpoint, body.slice(0, 200));
+  }
+
+  const text = await response.text();
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new BadResponseError(endpoint, text.length);
+  }
+
+  if (
+    parsed &&
+    typeof parsed === "object" &&
+    !Array.isArray(parsed) &&
+    "status" in parsed &&
+    (parsed as { status: unknown }).status === "error"
+  ) {
+    const msg = String((parsed as { message?: unknown }).message ?? "unknown error");
+    throw new PropertyDataError(response.status, endpoint, msg);
+  }
+
+  return JSON.stringify(parsed, null, 2);
+}

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/tools/endpoints.ts

@@ -0,0 +1,27 @@
+import { propertyDataCall } from "../lib/propertydata-api.js";
+
+// Every endpoint tool takes the same shape: { accountId, ...params }.
+// Per-tool param schemas are enforced by zod in index.ts; this layer only
+// forwards values to the HTTP client.
+
+type Args = Record<string, unknown> & { accountId: string };
+
+function call(toolName: string, endpoint: string, args: Args): Promise<string> {
+  const { accountId, ...rest } = args;
+  return propertyDataCall({
+    endpoint,
+    toolName,
+    accountId,
+    params: rest as Record<string, string | number | undefined>,
+  });
+}
+
+export const valuationSale = (a: Args) => call("property-data-valuation-sale", "valuation-sale", a);
+export const valuationRent = (a: Args) => call("property-data-valuation-rent", "valuation-rent", a);
+export const prices = (a: Args) => call("property-data-prices", "prices", a);
+export const pricesRent = (a: Args) => call("property-data-prices-rent", "prices-rent", a);
+export const soldPrices = (a: Args) => call("property-data-sold-prices", "sold-prices", a);
+export const demand = (a: Args) => call("property-data-demand", "demand", a);
+export const yields = (a: Args) => call("property-data-yields", "yields", a);
+export const growth = (a: Args) => call("property-data-growth", "growth", a);
+export const nationalHpi = (a: Args) => call("property-data-national-hpi", "national-hpi", a);

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/tools/key-deregister.ts

@@ -0,0 +1,21 @@
+import { getSession } from "../lib/neo4j.js";
+
+export async function keyDeregister(params: { accountId: string }): Promise<void> {
+  const { accountId } = params;
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (k:PropertyDataKey {accountId: $accountId})
+       DELETE k
+       RETURN count(k) AS deleted`,
+      { accountId },
+    );
+    const deleted = result.records[0]?.get("deleted")?.toNumber?.() ?? 0;
+    if (deleted === 0) {
+      throw new Error("No PropertyData API key is registered for this account.");
+    }
+  } finally {
+    await session.close();
+  }
+  console.error(`[property-data] key-op op=deregister account=${accountId}`);
+}

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/tools/key-list.ts

@@ -0,0 +1,10 @@
+import { loadAccountKey } from "../lib/propertydata-api.js";
+
+export async function keyList(params: { accountId: string }): Promise<string> {
+  const key = await loadAccountKey(params.accountId);
+  console.error(`[property-data] key-op op=list account=${params.accountId}`);
+  if (!key) {
+    return "No PropertyData API key registered. Use property-data-key-register to add one.";
+  }
+  return `PropertyData API key registered (created: ${key.createdAt}, updated: ${key.updatedAt}). Key value is encrypted and cannot be retrieved.`;
+}

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/tools/key-register.ts

@@ -0,0 +1,58 @@
+import { getSession } from "../lib/neo4j.js";
+import { encrypt } from "../lib/crypto.js";
+import { PropertyDataError } from "../lib/propertydata-api.js";
+
+const BASE_URL = "https://api.propertydata.co.uk";
+const REQUEST_TIMEOUT_MS = 15_000;
+
+// Validate by hitting a cheap endpoint that returns success on any valid key:
+// /national-hpi takes no postcode and is rate-cheap. Treat a 200 as the key
+// passing PropertyData's authentication check; treat 401/403 as an explicit
+// key rejection so the operator gets an actionable message; treat anything
+// else as an unverified-key error (network, upstream outage).
+async function validateApiKey(apiKey: string): Promise<void> {
+  const url = `${BASE_URL}/national-hpi?key=${encodeURIComponent(apiKey)}`;
+  const response = await fetch(url, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  });
+  if (response.status === 401 || response.status === 403) {
+    throw new Error(`PropertyData rejected the API key (HTTP ${response.status}).`);
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new PropertyDataError(response.status, "national-hpi", body.slice(0, 200));
+  }
+}
+
+export async function keyRegister(params: {
+  apiKey: string;
+  accountId: string;
+}): Promise<void> {
+  const { apiKey, accountId } = params;
+
+  await validateApiKey(apiKey);
+
+  const encryptedKey = encrypt(apiKey);
+  const now = new Date().toISOString();
+
+  const session = getSession();
+  try {
+    await session.run(
+      `CREATE INDEX property_data_key_account IF NOT EXISTS
+       FOR (k:PropertyDataKey) ON (k.accountId)`,
+      {},
+    );
+
+    await session.run(
+      `MERGE (k:PropertyDataKey {accountId: $accountId})
+       ON CREATE SET k.encryptedKey = $encryptedKey, k.createdAt = $now, k.updatedAt = $now
+       ON MATCH  SET k.encryptedKey = $encryptedKey, k.updatedAt = $now`,
+      { accountId, encryptedKey, now },
+    );
+  } finally {
+    await session.close();
+  }
+
+  console.error(`[property-data] key-op op=register account=${accountId}`);
+}

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"],
+  "exclude": ["src/**/__tests__/**", "src/**/*.test.ts"]
+}

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["src/**/__tests__/**/*.test.ts"],
+    environment: "node",
+  },
+});

package/payload/premium-plugins/real-agent/plugins/property-data/skills/property-data/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: property-data
+description: "Given a UK postcode plus property attributes (type, bedrooms, area), return structured market data — comparable sold prices, asking-price baselines, demand index, rental yield, and growth signals — for valuation and negotiation workflows."
+---
+
+# Property Data
+
+Outcome: given a UK postcode and property attributes, return structured market evidence — comparables, asking prices, sold prices, demand, yield, growth — so the valuer composes a valuation brief and the negotiator backs an offer position with numbers, not prose.
+
+## When to use
+
+Trigger phrases:
+- "comps for [address|postcode]"
+- "what are properties going for in [postcode]"
+- "demand in [postcode]"
+- "yield on [bedrooms]-bed in [postcode]"
+- "asking prices around [postcode]"
+- "what's it worth — [postcode], [type], [beds]"
+- "sold prices on [street|postcode]"
+- "growth in [postcode]"
+
+## Inputs required
+
+- **Postcode** — UK outcode (e.g. `SN7`) or full postcode (e.g. `SN7 8AA`). The PropertyData endpoints accept either; outcode broadens the sample, full postcode tightens it.
+- **Property type** — one of: `detached`, `semi-detached`, `terraced`, `flat`. Required for valuation and price-distribution endpoints.
+- **Bedrooms** — integer. Required for valuation and yield endpoints.
+- **Internal area (sq ft)** — required for `valuation-sale` and `valuation-rent` point estimates. If unknown, fall back to `prices` / `prices-rent` for a distribution and state the area assumption.
+
+## Tools
+
+| Tool | Use for | Required inputs |
+|---|---|---|
+| `property-data-valuation-sale` | Point sale-price estimate | postcode, type, bedrooms, bathrooms, internal_area |
+| `property-data-valuation-rent` | Point rent estimate | postcode, type, bedrooms, bathrooms, internal_area |
+| `property-data-prices` | Asking-price distribution (mean / median / 80th pct) | postcode, type, bedrooms |
+| `property-data-prices-rent` | Rent asking-price distribution | postcode, type, bedrooms |
+| `property-data-sold-prices` | Land Registry sold transactions | postcode (max_age, type, bedrooms optional) |
+| `property-data-demand` | Supply count + days to sell-STC | postcode |
+| `property-data-yields` | Gross rental yield | postcode, bedrooms |
+| `property-data-growth` | Short and long-term price growth | postcode |
+| `property-data-national-hpi` | UK national HPI series | (none) |
+
+## Output
+
+Return the structured `data` payload directly to the caller (valuer / negotiator). Do not collapse it to prose — downstream skills (`comparable-finder`, `local-market-stats`, `pricing-scenario-builder`) consume the fields.
+
+## Failure modes
+
+- `Error: key-not-registered` — surface the registration prompt: "PropertyData API key not registered. Register it with `property-data-key-register`."
+- `Error: http-4xx` — bad input (usually invalid postcode or unsupported type). Restate the inputs the operator gave; do not retry blindly.
+- `Error: http-5xx` — PropertyData upstream outage. Surface the failure and fall back to Loop sold-prices (`loop-property-sold`) if available.
+- Empty `data` — the postcode has insufficient comparables. Broaden the postcode (full → outcode) and retry once; if still empty, surface "no PropertyData comparables for this postcode" and let the agent fall back.
+
+## Do not
+
+- Do not compose a valuation figure or asking-price range in this skill — that is the valuer's output contract, composed downstream from the structured data returned here.
+- Do not call any endpoint without a postcode argument (except `national-hpi`).
+- Do not invent fields not returned by PropertyData. If a field is absent, name it as a gap.

package/payload/server/{chunk-CWI7NOWK.js → chunk-2IKQERHN.js}

@@ -3732,12 +3732,40 @@ var emitMissingOnResolve = (..._args) => null;
 // app/lib/claude-agent/spawn-env.ts
 var getBundleMtimeIso = (..._args) => null;
 
-// app/lib/claude-agent/stream-log-writer.ts
-var appendStreamLogLine = (..._args) => null;
-
 // app/lib/claude-agent/summary-helpers.ts
 var stripAttachmentMetaSuffix = (..._args) => null;
 
+// ../lib/require-port-env/src/index.ts
+var MissingPortEnvError = class extends Error {
+  envName;
+  tag;
+  failLine;
+  constructor(envName, tag, failLine, message) {
+    super(message);
+    this.name = "MissingPortEnvError";
+    this.envName = envName;
+    this.tag = tag;
+    this.failLine = failLine;
+  }
+};
+var VALID_PORT_MIN = 1;
+var VALID_PORT_MAX = 65535;
+function requirePortEnv(envName, options = {}) {
+  const tag = options.tag ?? "port-env";
+  const failLine = options.failLine ?? "missing-port-env";
+  const raw2 = process.env[envName];
+  if (raw2 === void 0 || raw2 === "") {
+    const msg = `[${tag}] ${failLine} reason=missing-env env=${envName}`;
+    throw new MissingPortEnvError(envName, tag, failLine, msg);
+  }
+  const parsed = Number.parseInt(raw2, 10);
+  if (!Number.isInteger(parsed) || parsed < VALID_PORT_MIN || parsed > VALID_PORT_MAX || String(parsed) !== raw2.trim()) {
+    const msg = `[${tag}] ${failLine} reason=invalid-port-env env=${envName} value=${JSON.stringify(raw2)}`;
+    throw new MissingPortEnvError(envName, tag, failLine, msg);
+  }
+  return parsed;
+}
+
 // server/routes/_helpers.ts
 async function safeJson(c) {
   try {
@@ -4399,8 +4427,8 @@ export {
   reconcileEnabledPlugins,
   emitMissingOnResolve,
   getBundleMtimeIso,
-  appendStreamLogLine,
   stripAttachmentMetaSuffix,
+  requirePortEnv,
   safeJson,
   requireAdminSession,
   tryCookieBridgeForConversation,

package/payload/server/maxy-edge.js

@@ -14,11 +14,12 @@ import {
   parseCookieValue,
   primeSudo,
   requireAdminCookie,
+  requirePortEnv,
   sanitizeClientCorrId,
   streamActionEvents,
   vncLog,
   websockifyLog
-} from "./chunk-CWI7NOWK.js";
+} from "./chunk-2IKQERHN.js";
 import "./chunk-X3Y6ENKA.js";
 import "./chunk-JSBRDJBE.js";
 
@@ -596,32 +597,57 @@ function countClientErrors24h() {
 
 // server/routes/admin/version.ts
 var PLATFORM_ROOT = process.env.MAXY_PLATFORM_ROOT ?? resolve(process.cwd(), "..");
-var brandHostname = "maxy";
-var brandNpmPackage = "@rubytech/create-maxy";
-var brandJsonPath = join2(PLATFORM_ROOT, "config", "brand.json");
-if (existsSync3(brandJsonPath)) {
+var DEFAULT_HOSTNAME = "maxy";
+var DEFAULT_NPM_PACKAGE = "@rubytech/create-maxy";
+var FETCH_TIMEOUT_MS = 5e3;
+var fallbackLogged = /* @__PURE__ */ new Set();
+function logFallbackOnce(reason, field, usingDefault) {
+  const key = `${reason}:${field}`;
+  if (fallbackLogged.has(key)) return;
+  fallbackLogged.add(key);
+  console.log(`[admin/version] brand-config-fallback reason=${reason} field=${field} using=${usingDefault}`);
+}
+function resolveBrandConfig() {
+  const brandJsonPath = join2(PLATFORM_ROOT, "config", "brand.json");
+  if (!existsSync3(brandJsonPath)) {
+    logFallbackOnce("file-missing", "hostname", DEFAULT_HOSTNAME);
+    logFallbackOnce("file-missing", "npm.packageName", DEFAULT_NPM_PACKAGE);
+    return { hostname: DEFAULT_HOSTNAME, npmPackage: DEFAULT_NPM_PACKAGE };
+  }
+  let parsed;
   try {
-    const brand = JSON.parse(readFileSync2(brandJsonPath, "utf-8"));
-    if (brand.hostname) brandHostname = brand.hostname;
-    if (brand.npm?.packageName) brandNpmPackage = brand.npm.packageName;
+    parsed = JSON.parse(readFileSync2(brandJsonPath, "utf-8"));
   } catch {
+    logFallbackOnce("parse-failed", "hostname", DEFAULT_HOSTNAME);
+    logFallbackOnce("parse-failed", "npm.packageName", DEFAULT_NPM_PACKAGE);
+    return { hostname: DEFAULT_HOSTNAME, npmPackage: DEFAULT_NPM_PACKAGE };
   }
+  let hostname = DEFAULT_HOSTNAME;
+  let npmPackage = DEFAULT_NPM_PACKAGE;
+  if (typeof parsed?.hostname === "string" && parsed.hostname) {
+    hostname = parsed.hostname;
+  } else {
+    logFallbackOnce("field-missing", "hostname", DEFAULT_HOSTNAME);
+  }
+  if (typeof parsed?.npm?.packageName === "string" && parsed.npm.packageName) {
+    npmPackage = parsed.npm.packageName;
+  } else {
+    logFallbackOnce("field-missing", "npm.packageName", DEFAULT_NPM_PACKAGE);
+  }
+  return { hostname, npmPackage };
 }
-var VERSION_FILE = resolve(PLATFORM_ROOT, `config/.${brandHostname}-version`);
-var NPM_PACKAGE = brandNpmPackage;
-var REGISTRY_URL = `https://registry.npmjs.org/${NPM_PACKAGE}/latest`;
-var FETCH_TIMEOUT_MS = 5e3;
 var PROCESS_STARTED_AT = (/* @__PURE__ */ new Date()).toISOString();
-function readInstalled() {
-  if (!existsSync3(VERSION_FILE)) return "unknown";
-  const content = readFileSync2(VERSION_FILE, "utf-8").trim();
+function readInstalled(versionFile) {
+  if (!existsSync3(versionFile)) return "unknown";
+  const content = readFileSync2(versionFile, "utf-8").trim();
   return content || "unknown";
 }
-async function fetchLatest() {
+async function fetchLatest(npmPackage) {
+  const registryUrl = `https://registry.npmjs.org/${npmPackage}/latest`;
   try {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-    const res = await fetch(REGISTRY_URL, { signal: controller.signal });
+    const res = await fetch(registryUrl, { signal: controller.signal });
     clearTimeout(timer);
     if (!res.ok) {
       console.error(`[admin/version] npm registry returned ${res.status}`);
@@ -654,13 +680,15 @@ function isNewer(latest, installed) {
 }
 var app5 = new Hono();
 app5.get("/", async (c) => {
-  const installed = readInstalled();
-  const latest = await fetchLatest();
+  const { hostname, npmPackage } = resolveBrandConfig();
+  const versionFile = resolve(PLATFORM_ROOT, `config/.${hostname}-version`);
+  const installed = readInstalled(versionFile);
+  const latest = await fetchLatest(npmPackage);
   const updateAvailable = installed !== "unknown" && latest !== null && isNewer(latest, installed);
   const outcome = installed === "unknown" ? "stale-version-file" : latest === null ? "fetch-failed" : "ok";
   const clientErrors24h = countClientErrors24h();
   console.log(
-    `[admin/version] outcome=${outcome} installed=${installed} latest=${latest ?? "null"} updateAvailable=${updateAvailable} clientErrors24h=${clientErrors24h} processStartedAt=${PROCESS_STARTED_AT}`
+    `[admin/version] outcome=${outcome} installed=${installed} latest=${latest ?? "null"} updateAvailable=${updateAvailable} clientErrors24h=${clientErrors24h} processStartedAt=${PROCESS_STARTED_AT} versionFile=${versionFile} npmPackage=${npmPackage}`
   );
   return c.json({ installed, latest, updateAvailable, clientErrors24h, processStartedAt: PROCESS_STARTED_AT });
 });
@@ -730,10 +758,10 @@ function inlineAsset(filePath) {
 function readString(value, fallback) {
   return typeof value === "string" && value.length > 0 ? value : fallback;
 }
-function loadBrand(brandJsonPath2, assetsDir = "") {
-  if (!brandJsonPath2 || !existsSync4(brandJsonPath2)) return { ...BRAND_DEFAULTS };
+function loadBrand(brandJsonPath, assetsDir = "") {
+  if (!brandJsonPath || !existsSync4(brandJsonPath)) return { ...BRAND_DEFAULTS };
   try {
-    const parsed = JSON.parse(readFileSync3(brandJsonPath2, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(brandJsonPath, "utf-8"));
     const logoFile = typeof parsed.assets?.logo === "string" ? parsed.assets.logo : null;
     const logoDataUri = logoFile && assetsDir ? inlineAsset(join3(assetsDir, logoFile)) : null;
     return {
@@ -853,10 +881,10 @@ watchFile(ALIAS_DOMAINS_PATH, { interval: 2e3 }, () => {
 function isPublicHost(host) {
   return host.startsWith("public.") || aliasDomains.has(host);
 }
-var EDGE_PORT = parseInt(process.env.EDGE_PORT ?? process.env.PORT ?? "19200", 10);
+var EDGE_PORT = requirePortEnv("EDGE_PORT", { tag: "edge" });
 var EDGE_HOSTNAME = process.env.EDGE_HOSTNAME ?? "0.0.0.0";
 var UPSTREAM_HOST = process.env.MAXY_UI_HOST ?? "127.0.0.1";
-var UPSTREAM_PORT = parseInt(process.env.MAXY_UI_PORT ?? "19199", 10);
+var UPSTREAM_PORT = requirePortEnv("MAXY_UI_PORT", { tag: "edge" });
 var WEBSOCKIFY_HOST = process.env.WEBSOCKIFY_HOST ?? "127.0.0.1";
 var WEBSOCKIFY_PORT2 = parseInt(process.env.WEBSOCKIFY_PORT ?? String(WEBSOCKIFY_PORT), 10);
 var HOP_BY_HOP2 = /* @__PURE__ */ new Set([