@rubytech/create-maxy-code 0.1.62 → 0.1.64

package/payload/platform/plugins/epc/mcp/src/index.ts

@@ -1,156 +0,0 @@
-// Logging-tee was a platform-wrapper concern: the platform's mcp-spawn-tee
-// pipes our stderr where it wants. In standalone mode (Claude Code native
-// spawn) the host owns the stderr pipe. Either way, we just write to stderr.
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { keyRegister } from "./tools/key-register.js";
-import { keyDeregister } from "./tools/key-deregister.js";
-import { keyList } from "./tools/key-list.js";
-import { epcLookupByAddress, epcLookupByUprn } from "./tools/lookup.js";
-import { closeDriver } from "./lib/neo4j.js";
-import {
-  KeyNotRegisteredError,
-  EpcError,
-  BadResponseError,
-} from "./lib/epc-api.js";
-import { selectKeyStore } from "./lib/key-store.js";
-
-const accountId = process.env.ACCOUNT_ID ?? "local";
-
-const server = new McpServer({
-  name: "maxy-epc",
-  version: "0.1.0",
-});
-
-const store = selectKeyStore();
-console.error(
-  `[epc] server started, account=${accountId} backend=${store.backendName} path=${store.backendPath}`,
-);
-
-function errorEnvelope(err: unknown): { content: { type: "text"; text: string }[]; isError: true } {
-  let text: string;
-  if (err instanceof KeyNotRegisteredError) {
-    text =
-      "Error: key-not-registered. Register an EPC API key with epc-key-register before calling this tool.";
-  } else if (err instanceof EpcError) {
-    text = `Error: http-${err.status} from EPC register. ${err.upstreamMessage}`;
-  } else if (err instanceof BadResponseError) {
-    text = `Error: bad-response from EPC register (non-JSON, length=${err.length}).`;
-  } else {
-    text = `Error: ${err instanceof Error ? err.message : String(err)}`;
-  }
-  return { content: [{ type: "text" as const, text }], isError: true };
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Key management
-// ─────────────────────────────────────────────────────────────────
-
-server.tool(
-  "epc-key-register",
-  "Register the account's EPC register credential. The credential is the email that generated the API key on the EPC dashboard, a colon, then the API key (format: email:api-key). Validates against the EPC register, encrypts with AES-256-GCM, and stores in Neo4j. One credential per account; re-registering overwrites.",
-  {
-    apiKey: z
-      .string()
-      .min(8)
-      .describe(
-        "EPC credential in the form email:api-key. The email is the account that generated the key at epc.opendatacommunities.org.",
-      ),
-  },
-  async ({ apiKey }) => {
-    try {
-      await keyRegister({ apiKey, accountId });
-      return {
-        content: [
-          { type: "text" as const, text: "EPC API key registered successfully." },
-        ],
-      };
-    } catch (err) {
-      return errorEnvelope(err);
-    }
-  },
-);
-
-server.tool(
-  "epc-key-deregister",
-  "Remove the account's EPC API credential. The encrypted credential is permanently deleted from Neo4j.",
-  {},
-  async () => {
-    try {
-      await keyDeregister({ accountId });
-      return {
-        content: [{ type: "text" as const, text: "EPC API key deregistered." }],
-      };
-    } catch (err) {
-      return errorEnvelope(err);
-    }
-  },
-);
-
-server.tool(
-  "epc-key-list",
-  "Show whether an EPC API credential is registered for this account. Never reveals the credential value.",
-  {},
-  async () => {
-    try {
-      const text = await keyList({ accountId });
-      return { content: [{ type: "text" as const, text }] };
-    } catch (err) {
-      return errorEnvelope(err);
-    }
-  },
-);
-
-// ─────────────────────────────────────────────────────────────────
-// Lookup
-// ─────────────────────────────────────────────────────────────────
-
-server.tool(
-  "epc-lookup-by-address",
-  "Look up the most recent Energy Performance Certificate per matched property for a UK address. Returns total_floor_area_m2, total_floor_area_sqft (m² × 10.7639), current and potential energy ratings, lodgement date, address, and UPRN. Multiple matches surface as an array. Zero matches return an empty array with status ok. Use to derive subject-property sqft for preval valuation.",
-  {
-    address: z.string().min(2).describe("UK address line one (street and house number / name)"),
-    postcode: z
-      .string()
-      .optional()
-      .describe("Full UK postcode (optional but recommended to narrow matches)"),
-  },
-  async ({ address, postcode }) => {
-    try {
-      const text = await epcLookupByAddress({ accountId, address, postcode });
-      return { content: [{ type: "text" as const, text }] };
-    } catch (err) {
-      return errorEnvelope(err);
-    }
-  },
-);
-
-server.tool(
-  "epc-lookup-by-uprn",
-  "Look up the most recent Energy Performance Certificate for a specific UPRN. Returns the same shape as epc-lookup-by-address. Use when the property's UPRN is already known from property-data-address-match-uprn or Land Registry.",
-  {
-    uprn: z.string().min(1).describe("UK Unique Property Reference Number"),
-  },
-  async ({ uprn }) => {
-    try {
-      const text = await epcLookupByUprn({ accountId, uprn });
-      return { content: [{ type: "text" as const, text }] };
-    } catch (err) {
-      return errorEnvelope(err);
-    }
-  },
-);
-
-// ─────────────────────────────────────────────────────────────────
-// Lifecycle
-// ─────────────────────────────────────────────────────────────────
-
-process.on("SIGINT", async () => {
-  await closeDriver();
-  process.exit(0);
-});
-
-const transport = new StdioServerTransport();
-await server.connect(transport);

package/payload/platform/plugins/epc/mcp/src/lib/crypto.ts

@@ -1,79 +0,0 @@
-import { randomBytes, createCipheriv, createDecipheriv } from "node:crypto";
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { homedir } from "node:os";
-
-const ALGORITHM = "aes-256-gcm";
-const KEY_LENGTH = 32;
-const IV_LENGTH = 12;
-const AUTH_TAG_LENGTH = 16;
-const KEY_FILE_NAME = ".epc-encryption-key";
-
-function resolveConfigDir(): string {
-  try {
-    const platformRoot = process.env.PLATFORM_ROOT;
-    if (platformRoot) {
-      const brandPath = resolve(platformRoot, "config/brand.json");
-      const brand = JSON.parse(readFileSync(brandPath, "utf-8"));
-      if (brand.configDir) return brand.configDir;
-    }
-  } catch {
-    // Fall back to default
-  }
-  return ".maxy";
-}
-
-function keyFilePath(): string {
-  return resolve(homedir(), resolveConfigDir(), KEY_FILE_NAME);
-}
-
-function loadOrGenerateKey(): Buffer {
-  const path = keyFilePath();
-  if (existsSync(path)) {
-    const hex = readFileSync(path, "utf-8").trim();
-    const buf = Buffer.from(hex, "hex");
-    if (buf.length !== KEY_LENGTH) {
-      throw new Error(
-        `Encryption key at ${path} is ${buf.length} bytes, expected ${KEY_LENGTH}. ` +
-          `Delete the file and re-register the EPC API key.`,
-      );
-    }
-    return buf;
-  }
-  const key = randomBytes(KEY_LENGTH);
-  writeFileSync(path, key.toString("hex"), { mode: 0o600 });
-  console.error(`[epc] encryption key generated at ${path}`);
-  return key;
-}
-
-export function encrypt(plaintext: string): string {
-  const key = loadOrGenerateKey();
-  const iv = randomBytes(IV_LENGTH);
-  const cipher = createCipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
-  let encrypted = cipher.update(plaintext, "utf-8", "hex");
-  encrypted += cipher.final("hex");
-  const authTag = cipher.getAuthTag().toString("hex");
-  return `${iv.toString("hex")}:${encrypted}:${authTag}`;
-}
-
-export function decrypt(encryptedValue: string): string {
-  const parts = encryptedValue.split(":");
-  if (parts.length !== 3) {
-    throw new Error("Malformed encrypted value — expected iv:ciphertext:authTag");
-  }
-  const [ivHex, ciphertextHex, authTagHex] = parts;
-  const path = keyFilePath();
-  if (!existsSync(path)) {
-    throw new Error(
-      `Encryption key not found at ${path}. The stored EPC API key is unrecoverable. Re-register.`,
-    );
-  }
-  const key = loadOrGenerateKey();
-  const iv = Buffer.from(ivHex, "hex");
-  const authTag = Buffer.from(authTagHex, "hex");
-  const decipher = createDecipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
-  decipher.setAuthTag(authTag);
-  let decrypted = decipher.update(ciphertextHex, "hex", "utf-8");
-  decrypted += decipher.final("utf-8");
-  return decrypted;
-}

package/payload/platform/plugins/epc/mcp/src/lib/epc-api.ts

@@ -1,241 +0,0 @@
-import { selectKeyStore } from "./key-store.js";
-
-// gov.uk EPC register HTTP client. The register lives at
-// epc.opendatacommunities.org and is reached via Basic auth where the
-// credential is `<email>:<api-key>` (the email is the account that
-// generated the key on the dashboard). We store the credential as a single
-// colon-joined string so the key-management surface mirrors property-data
-// exactly (one `apiKey` field per account).
-//
-// Response shape (domestic/search):
-//   { "column-names": [...], "rows": [ { "lmk-key": "...",
-//     "address1": "...", "address2": "...", "address3": "...",
-//     "posttown": "...", "postcode": "...", "uprn": "...",
-//     "current-energy-rating": "C", "potential-energy-rating": "B",
-//     "lodgement-date": "2023-05-15", "total-floor-area": "75.0", ... } ] }
-//
-// Multiple EPCs per property appear as separate rows (one per lodgement).
-// Callers group by UPRN (or address fallback) and pick the most-recent
-// row per property.
-
-export const BASE_URL = "https://epc.opendatacommunities.org/api/v1";
-export const REQUEST_TIMEOUT_MS = 15_000;
-export const M2_TO_SQFT = 10.7639;
-
-export class KeyNotRegisteredError extends Error {
-  constructor() {
-    super("key-not-registered");
-    this.name = "KeyNotRegisteredError";
-  }
-}
-
-export class EpcError extends Error {
-  constructor(
-    public readonly status: number,
-    public readonly endpoint: string,
-    public readonly upstreamMessage: string,
-  ) {
-    super(`http-${status} from EPC endpoint=${endpoint}: ${upstreamMessage}`);
-    this.name = "EpcError";
-  }
-}
-
-export class BadResponseError extends Error {
-  constructor(public readonly endpoint: string, public readonly length: number) {
-    super(`bad-response from EPC endpoint=${endpoint} (non-JSON, length=${length})`);
-    this.name = "BadResponseError";
-  }
-}
-
-export interface EpcKeyMeta {
-  createdAt: string;
-  updatedAt: string;
-}
-
-export async function loadAccountKey(accountId: string): Promise<EpcKeyMeta | null> {
-  const stored = await selectKeyStore().load(accountId);
-  if (!stored) return null;
-  return { createdAt: stored.createdAt, updatedAt: stored.updatedAt };
-}
-
-export async function resolveAccountApiKey(accountId: string): Promise<string> {
-  const envKey = process.env.EPC_API_KEY;
-  if (envKey && envKey.trim()) return envKey.trim();
-  const stored = await selectKeyStore().load(accountId);
-  if (!stored) throw new KeyNotRegisteredError();
-  return stored.apiKey;
-}
-
-function basicAuthHeader(credential: string): string {
-  return `Basic ${Buffer.from(credential, "utf-8").toString("base64")}`;
-}
-
-export interface EpcRow {
-  "lmk-key"?: string;
-  address1?: string;
-  address2?: string;
-  address3?: string;
-  posttown?: string;
-  postcode?: string;
-  uprn?: string;
-  "current-energy-rating"?: string;
-  "potential-energy-rating"?: string;
-  "lodgement-date"?: string;
-  "total-floor-area"?: string;
-  [k: string]: unknown;
-}
-
-export interface EpcSearchOptions {
-  toolName: string;
-  accountId: string;
-  // Address-or-uprn token recorded on the log line. Optional so key-management
-  // tools that share the call helper can omit it.
-  identifier: string;
-  // Endpoint-specific query parameters (postcode, address, uprn, size, ...).
-  params: Record<string, string | number | undefined>;
-}
-
-interface CallResult {
-  // The HTTP status of the upstream response. Useful for the address-lookup
-  // wrapper which converts 404 into an empty-rows ok response.
-  status: number;
-  rows: EpcRow[];
-}
-
-export async function epcSearch(opts: EpcSearchOptions): Promise<CallResult> {
-  const { toolName, accountId, identifier, params } = opts;
-  const credential = await resolveAccountApiKey(accountId);
-
-  const search = new URLSearchParams();
-  for (const [k, v] of Object.entries(params)) {
-    if (v === undefined || v === null || v === "") continue;
-    search.set(k, String(v));
-  }
-  const endpoint = "domestic/search";
-  const url = `${BASE_URL}/${endpoint}?${search.toString()}`;
-
-  const start = Date.now();
-  const response = await fetch(url, {
-    headers: {
-      Accept: "application/json",
-      Authorization: basicAuthHeader(credential),
-    },
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-  });
-  const ms = Date.now() - start;
-
-  const statusTag = response.ok
-    ? "ok"
-    : response.status === 404
-      ? "http-404"
-      : `http-${Math.floor(response.status / 100)}xx`;
-  console.error(
-    `[epc] tool=${toolName} account=${accountId} address="${identifier}" status=${statusTag} ms=${ms}`,
-  );
-
-  // 404 is a valid outcome — no EPC on file for the address. Surface to the
-  // caller as an empty result set; the wrapper turns it into ok+[].
-  if (response.status === 404) {
-    return { status: 404, rows: [] };
-  }
-
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new EpcError(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) ||
-    !("rows" in parsed)
-  ) {
-    throw new BadResponseError(endpoint, text.length);
-  }
-
-  const rows = (parsed as { rows: unknown }).rows;
-  if (!Array.isArray(rows)) {
-    throw new BadResponseError(endpoint, text.length);
-  }
-
-  return { status: response.status, rows: rows as EpcRow[] };
-}
-
-export interface EpcMatch {
-  total_floor_area_m2: number | null;
-  total_floor_area_sqft: number | null;
-  current_energy_rating: string | null;
-  potential_energy_rating: string | null;
-  lodgement_date: string | null;
-  address: string;
-  uprn: string | null;
-}
-
-// Compose the human-readable address from the upstream row's parts. Empty
-// segments are dropped; segments are uppercase in the API and join with
-// ", ".
-function rowAddress(row: EpcRow): string {
-  const parts = [row.address1, row.address2, row.address3, row.posttown, row.postcode]
-    .map((s) => (typeof s === "string" ? s.trim() : ""))
-    .filter((s) => s.length > 0);
-  return parts.join(", ");
-}
-
-function parseFloorArea(row: EpcRow): number | null {
-  const raw = row["total-floor-area"];
-  if (raw == null || raw === "") return null;
-  const n = Number(raw);
-  return Number.isFinite(n) ? n : null;
-}
-
-// Group rows by UPRN (or address1+postcode when UPRN is absent), then pick
-// the most-recent EPC per group by lodgement date. Rows with no lodgement
-// date sort last.
-export function groupAndPickMostRecent(rows: EpcRow[]): EpcMatch[] {
-  const buckets = new Map<string, EpcRow[]>();
-  for (const row of rows) {
-    const uprn = typeof row.uprn === "string" ? row.uprn.trim() : "";
-    const key = uprn || `${row.address1 ?? ""}|${row.postcode ?? ""}`.toLowerCase();
-    const existing = buckets.get(key);
-    if (existing) existing.push(row);
-    else buckets.set(key, [row]);
-  }
-  const out: EpcMatch[] = [];
-  for (const bucket of buckets.values()) {
-    bucket.sort((a, b) => {
-      const da = String(a["lodgement-date"] ?? "");
-      const db = String(b["lodgement-date"] ?? "");
-      // Most-recent first: ISO dates string-sort correctly.
-      return db.localeCompare(da);
-    });
-    const winner = bucket[0];
-    const m2 = parseFloorArea(winner);
-    out.push({
-      total_floor_area_m2: m2,
-      total_floor_area_sqft: m2 == null ? null : Number((m2 * M2_TO_SQFT).toFixed(2)),
-      current_energy_rating:
-        typeof winner["current-energy-rating"] === "string"
-          ? (winner["current-energy-rating"] as string)
-          : null,
-      potential_energy_rating:
-        typeof winner["potential-energy-rating"] === "string"
-          ? (winner["potential-energy-rating"] as string)
-          : null,
-      lodgement_date:
-        typeof winner["lodgement-date"] === "string"
-          ? (winner["lodgement-date"] as string)
-          : null,
-      address: rowAddress(winner),
-      uprn: typeof winner.uprn === "string" && winner.uprn.length > 0 ? winner.uprn : null,
-    });
-  }
-  return out;
-}

package/payload/platform/plugins/epc/mcp/src/lib/file-crypto.ts

@@ -1,55 +0,0 @@
-import { randomBytes, createCipheriv, createDecipheriv } from "node:crypto";
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-
-// Standalone-mode crypto. Same AES-256-GCM envelope as crypto.ts, but the
-// encryption-key file path is passed in (not derived from PLATFORM_ROOT /
-// brand.json), so it can live under ~/.claude/ when the MCP is spawned by
-// Claude Code natively.
-
-const ALGORITHM = "aes-256-gcm";
-const KEY_LENGTH = 32;
-const IV_LENGTH = 12;
-const AUTH_TAG_LENGTH = 16;
-
-function loadOrGenerateKey(keyFilePath: string, label: string): Buffer {
-  if (existsSync(keyFilePath)) {
-    const hex = readFileSync(keyFilePath, "utf-8").trim();
-    const buf = Buffer.from(hex, "hex");
-    if (buf.length !== KEY_LENGTH) {
-      throw new Error(
-        `[${label}] encryption key at ${keyFilePath} is ${buf.length} bytes, expected ${KEY_LENGTH}.`,
-      );
-    }
-    return buf;
-  }
-  const key = randomBytes(KEY_LENGTH);
-  writeFileSync(keyFilePath, key.toString("hex"), { mode: 0o600 });
-  console.error(`[${label}] encryption key generated at ${keyFilePath}`);
-  return key;
-}
-
-export function encryptWith(plaintext: string, keyFilePath: string, label: string): string {
-  const key = loadOrGenerateKey(keyFilePath, label);
-  const iv = randomBytes(IV_LENGTH);
-  const cipher = createCipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
-  let encrypted = cipher.update(plaintext, "utf-8", "hex");
-  encrypted += cipher.final("hex");
-  const authTag = cipher.getAuthTag().toString("hex");
-  return `${iv.toString("hex")}:${encrypted}:${authTag}`;
-}
-
-export function decryptWith(encryptedValue: string, keyFilePath: string, label: string): string {
-  const parts = encryptedValue.split(":");
-  if (parts.length !== 3) {
-    throw new Error(`[${label}] bad encrypted envelope (expected iv:ct:tag)`);
-  }
-  const key = loadOrGenerateKey(keyFilePath, label);
-  const iv = Buffer.from(parts[0], "hex");
-  const ciphertext = parts[1];
-  const authTag = Buffer.from(parts[2], "hex");
-  const decipher = createDecipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
-  decipher.setAuthTag(authTag);
-  let plaintext = decipher.update(ciphertext, "hex", "utf-8");
-  plaintext += decipher.final("utf-8");
-  return plaintext;
-}