jpdcl 1.0.0

package/src/http.ts

@@ -0,0 +1,49 @@
+import makeFetchCookie from "fetch-cookie";
+import { CookieJar } from "tough-cookie";
+
+export class CookieHttpClient {
+  readonly jar: CookieJar;
+  readonly fetch: typeof globalThis.fetch;
+
+  constructor(serializedCookies?: string) {
+    this.jar = serializedCookies
+      ? CookieJar.deserializeSync(JSON.parse(serializedCookies))
+      : new CookieJar();
+    this.fetch = makeFetchCookie(globalThis.fetch, this.jar) as typeof globalThis.fetch;
+  }
+
+  serialize(): string {
+    return JSON.stringify(this.jar.serializeSync());
+  }
+}
+export function basicAuth(value: string): string {
+  return `Basic ${Buffer.from(value, "utf8").toString("base64")}`;
+}
+
+export function buildUrl(
+  baseUrl: string,
+  path: string,
+  params: Record<string, string | number | boolean | null | undefined> = {},
+): string {
+  let resolved = path;
+  const unused = { ...params };
+  for (const [key, rawValue] of Object.entries(params)) {
+    const marker = `{${key}}`;
+    if (resolved.includes(marker)) {
+      if (rawValue === undefined || rawValue === null) {
+        throw new Error(`Missing required URL parameter: ${key}`);
+      }
+      resolved = resolved.replaceAll(marker, encodeURIComponent(String(rawValue)));
+      delete unused[key];
+    }
+  }
+  const missing = [...resolved.matchAll(/\{([^}]+)\}/g)].map((match) => match[1]);
+  if (missing.length) throw new Error(`Missing required URL parameter(s): ${missing.join(", ")}`);
+
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const url = new URL(resolved.replace(/^\//, ""), base);
+  for (const [key, value] of Object.entries(unused)) {
+    if (value !== undefined && value !== null) url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from "./catalog.js";
+export * from "./config.js";
+export * from "./crypto.js";
+export * from "./credentials.js";
+export * from "./errors.js";
+export * from "./main-client.js";
+export * from "./ledger-client.js";
+export * from "./dates.js";
+export * from "./runtime.js";
+export * from "./session.js";
+export * from "./smart-client.js";
+export * from "./tariff.js";
+export * from "./types.js";

package/src/launcher.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+// MCP clients start the package without arguments. Any explicit argument selects
+// the human CLI, so `npx jpdcl` and `jpdcl auth status` can share one executable.
+if (process.argv.length > 2) {
+  await import("./cli.js");
+} else {
+  await import("./mcp-stdio.js");
+}

package/src/ledger-client.ts

@@ -0,0 +1,258 @@
+import * as cheerio from "cheerio";
+import { assertDateRange } from "./dates.js";
+import { JpdclError } from "./errors.js";
+import type { EndpointName } from "./catalog.js";
+import type { RequestOptions } from "./types.js";
+
+export const LEDGER_PORTAL_URL = "https://smartmeter1.jpdcl.co.in/smartmeter/";
+export const LEDGER_CONSUMER_ENDPOINT = new URL("assets/php/_getConsumerDetails.php", LEDGER_PORTAL_URL).toString();
+export const LEDGER_ALARM_ENDPOINT = new URL("assets/php/_getAlarmDetails.php", LEDGER_PORTAL_URL).toString();
+
+export interface LedgerReading {
+  observedAt: string;
+  cumulative: {
+    importKwh: number;
+    exportKwh: number;
+    netImportKwh: number;
+    importKvah: number;
+    exportKvah: number;
+    netImportKvah: number;
+  };
+}
+
+export interface LedgerConsumerData {
+  _meta: {
+    dataClass: "observed";
+    source: "jpdcl-daily-meter-ledger";
+    sourceUrl: string;
+    fetchedAt: string;
+    publicConsumerLookup: true;
+  };
+  consumer: {
+    consumerId: string;
+    name: string | null;
+    smartMeterNumber: string | null;
+    installationDate: string | null;
+    netMeter: boolean | null;
+    earthLoading: boolean | null;
+  };
+  readings: LedgerReading[];
+}
+
+export interface LedgerPeriodOptions {
+  from?: string;
+  to?: string;
+  limit?: number;
+}
+
+export class JpdclLedgerClient {
+  private readonly cache = new Map<string, { at: number; value: LedgerConsumerData }>();
+
+  constructor(private readonly timeoutMs = 20_000, private readonly cacheMs = 30_000) {}
+
+  async consumer(consumerId: string): Promise<LedgerConsumerData> {
+    validateConsumerId(consumerId);
+    const cached = this.cache.get(consumerId);
+    if (cached && Date.now() - cached.at < this.cacheMs) return cached.value;
+    const response = await postForm(LEDGER_CONSUMER_ENDPOINT, { consumercode: consumerId }, this.timeoutMs);
+    if (!response.ok) throw new JpdclError(`Daily meter portal returned HTTP ${response.status}`, response.status);
+    const parsed = parseLedgerHtml(await response.text(), consumerId);
+    this.cache.set(consumerId, { at: Date.now(), value: parsed });
+    return parsed;
+  }
+
+  async alarms(meterNumber: string): Promise<Record<string, unknown>> {
+    if (!meterNumber.trim()) throw new JpdclError("A smart-meter number is required", 400);
+    const response = await postForm(LEDGER_ALARM_ENDPOINT, { meterSno: meterNumber.trim() }, this.timeoutMs);
+    if (!response.ok) throw new JpdclError(`Daily meter alarm endpoint returned HTTP ${response.status}`, response.status);
+    const body = await response.text();
+    const noAlarms = /no\s+alarms/i.test(body);
+    const tables = noAlarms ? [] : parseGenericTables(body);
+    return {
+      _meta: {
+        dataClass: "observed",
+        source: "jpdcl-daily-meter-ledger-alarm-endpoint",
+        sourceUrl: LEDGER_ALARM_ENDPOINT,
+        fetchedAt: new Date().toISOString(),
+      },
+      meterNumber,
+      hasAlarms: noAlarms ? false : tables.some((table) => table.rows.length > 0),
+      tables,
+      message: noAlarms ? "No Alarms" : undefined,
+    };
+  }
+
+  async request(name: EndpointName | string, options: RequestOptions = {}): Promise<unknown> {
+    if (name === "ledger_consumer_readings") {
+      const consumerId = String(options.params?.consumerId ?? (options.body as Record<string, unknown> | undefined)?.consumerId ?? "");
+      return this.consumer(consumerId);
+    }
+    if (name === "ledger_meter_alarms") {
+      const meterNumber = String(options.params?.meterNumber ?? (options.body as Record<string, unknown> | undefined)?.meterNumber ?? "");
+      return this.alarms(meterNumber);
+    }
+    throw new JpdclError(`Unknown daily meter ledger endpoint: ${name}`, 400);
+  }
+}
+
+export function parseLedgerHtml(html: string, expectedConsumerId: string): LedgerConsumerData {
+  const [profileHtml, tableHtml = ""] = html.split("||||");
+  const profile = parseProfile(profileHtml ?? "");
+  const $ = cheerio.load(tableHtml);
+  const readings: LedgerReading[] = [];
+  $("#readtable1 tbody tr").each((_, row) => {
+    const cells = $(row).find("td").map((__, cell) => $(cell).text().trim()).get();
+    if (cells.length < 7 || !/^\d{4}-\d{2}-\d{2}$/.test(cells[0] ?? "")) return;
+    const values = cells.slice(1, 7).map(Number);
+    if (values.some((value) => !Number.isFinite(value))) return;
+    readings.push({
+      observedAt: `${cells[0]}T00:00:00+05:30`,
+      cumulative: {
+        importKwh: values[0]!, exportKwh: values[1]!, netImportKwh: values[2]!,
+        importKvah: values[3]!, exportKvah: values[4]!, netImportKvah: values[5]!,
+      },
+    });
+  });
+  readings.sort((a, b) => b.observedAt.localeCompare(a.observedAt));
+  if (!readings.length) throw new JpdclError("No daily meter readings were returned for this consumer ID", 404);
+  const consumerId = profile["consumer id"] || expectedConsumerId;
+  return {
+    _meta: {
+      dataClass: "observed",
+      source: "jpdcl-daily-meter-ledger",
+      sourceUrl: LEDGER_CONSUMER_ENDPOINT,
+      fetchedAt: new Date().toISOString(),
+      publicConsumerLookup: true,
+    },
+    consumer: {
+      consumerId,
+      name: nullable(profile.name),
+      smartMeterNumber: nullable(profile["smart meter"]),
+      installationDate: validDate(profile["inatallation date"] ?? profile["installation date"]),
+      netMeter: yesNo(profile["net meter"]),
+      earthLoading: yesNo(profile["earth-loading"]),
+    },
+    readings,
+  };
+}
+
+export function ledgerPeriod(data: LedgerConsumerData, options: LedgerPeriodOptions = {}) {
+  const newestDate = data.readings[0]?.observedAt.slice(0, 10);
+  if (!newestDate) throw new JpdclError("The daily meter ledger is empty", 404);
+  const from = options.from ?? `${newestDate.slice(0, 7)}-01`;
+  const to = options.to ?? newestDate;
+  assertDateRange(from, to, { requireBoth: true });
+  const ascending = [...data.readings].sort((a, b) => a.observedAt.localeCompare(b.observedAt));
+  const selected = ascending.filter((reading) => {
+    const day = reading.observedAt.slice(0, 10);
+    return day >= from && day <= to;
+  });
+  const baseline = [...ascending].reverse().find((reading) => reading.observedAt.slice(0, 10) < from) ?? selected[0];
+  const latest = selected.at(-1);
+  const deltas = new Map<string, ReturnType<typeof subtractReadings>>();
+  for (let index = 1; index < ascending.length; index++) {
+    deltas.set(ascending[index]!.observedAt, subtractReadings(ascending[index]!, ascending[index - 1]!));
+  }
+  const requestedLimit = Math.max(0, Math.floor(options.limit ?? 35));
+  const returned = (requestedLimit === 0 ? [] : [...selected].reverse().slice(0, requestedLimit)).map((reading) => ({
+    ...reading,
+    usageSincePreviousObservation: deltas.get(reading.observedAt) ?? null,
+  }));
+  const periodUsage = baseline && latest ? subtractReadings(latest, baseline) : null;
+  const settlementCandidateKwh = periodUsage
+    ? data.consumer.netMeter ? Math.max(0, periodUsage.netImportKwh) : Math.max(0, periodUsage.importKwh)
+    : null;
+  const latestDay = new Date(`${newestDate}T00:00:00+05:30`).getTime();
+  return {
+    _meta: {
+      dataClass: "observed-with-deterministic-deltas",
+      source: data._meta.source,
+      fetchedAt: data._meta.fetchedAt,
+      calculation: "cumulative register subtraction",
+    },
+    consumer: data.consumer,
+    availability: {
+      firstObservation: data.readings.at(-1)?.observedAt ?? null,
+      latestObservation: data.readings[0]?.observedAt ?? null,
+      sourceRecordCount: data.readings.length,
+      freshnessHoursAtFetch: Math.max(0, Math.round((new Date(data._meta.fetchedAt).getTime() - latestDay) / 360_000) / 10),
+    },
+    period: {
+      from,
+      to,
+      baselineObservation: baseline?.observedAt ?? null,
+      latestObservation: latest?.observedAt ?? null,
+      usage: periodUsage,
+      provisionalBillableKwh: settlementCandidateKwh,
+      provisionalBillableBasis: data.consumer.netMeter ? "net-import-register-difference" : "import-register-difference",
+      warning: "Register differences are meter evidence, but JPDCL may use different billing cutoffs, adjustments, carry-forward credits, or settlement rules.",
+    },
+    readings: returned,
+    pagination: { returned: returned.length, matched: selected.length, limit: requestedLimit || null },
+  };
+}
+
+function subtractReadings(current: LedgerReading, previous: LedgerReading) {
+  const result: Record<string, number> = {};
+  for (const key of Object.keys(current.cumulative) as Array<keyof LedgerReading["cumulative"]>) {
+    result[key] = round3(current.cumulative[key] - previous.cumulative[key]);
+  }
+  return result as LedgerReading["cumulative"];
+}
+
+function parseProfile(html: string): Record<string, string> {
+  const $ = cheerio.load(html);
+  const profile: Record<string, string> = {};
+  $(".row").each((_, row) => {
+    const columns = $(row).find(".col").map((__, column) => $(column).text().replace(/\s+/g, " ").trim()).get();
+    const key = columns[0]?.toLowerCase();
+    if (!key) return;
+    profile[key] = $(row).find("input").attr("value")?.trim() ?? columns[1] ?? "";
+  });
+  return profile;
+}
+
+function parseGenericTables(html: string) {
+  const $ = cheerio.load(html);
+  return $("table").map((_, table) => {
+    const headers = $(table).find("thead th").map((__, cell) => $(cell).text().replace(/\s+/g, " ").trim()).get();
+    const rows = $(table).find("tbody tr").map((__, row) => [$(row).find("td").map((___, cell) => $(cell).text().replace(/\s+/g, " ").trim()).get()]).get();
+    return { headers, rows };
+  }).get();
+}
+
+async function postForm(url: string, fields: Record<string, string>, timeoutMs: number): Promise<Response> {
+  return fetch(url, {
+    method: "POST",
+    headers: {
+      Accept: "text/html, */*; q=0.01",
+      "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+      "X-Requested-With": "XMLHttpRequest",
+    },
+    body: new URLSearchParams(fields),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+}
+
+function validateConsumerId(value: string): void {
+  if (!/^\d{1,13}$/.test(value)) throw new JpdclError("Consumer ID must contain 1 to 13 digits", 400);
+}
+
+function nullable(value: string | undefined): string | null {
+  return value?.trim() ? value.trim() : null;
+}
+
+function validDate(value: string | undefined): string | null {
+  return value && /^\d{4}-\d{2}-\d{2}$/.test(value) && value !== "0000-00-00" ? value : null;
+}
+
+function yesNo(value: string | undefined): boolean | null {
+  if (!value) return null;
+  if (/^yes$/i.test(value.trim())) return true;
+  if (/^no$/i.test(value.trim())) return false;
+  return null;
+}
+
+function round3(value: number): number {
+  return Math.round((value + Number.EPSILON) * 1000) / 1000;
+}

package/src/main-client.ts

@@ -0,0 +1,230 @@
+import { endpointCatalog, isEndpointName, type EndpointName } from "./catalog.js";
+import { LOGIN_CREDENTIAL_HEADER, MAIN_API_URL, PORTAL_BASIC, mutationsEnabled } from "./config.js";
+import { decryptPayload, encryptPayload } from "./crypto.js";
+import { assertDateRange } from "./dates.js";
+import { resolveCredentials, type Credentials } from "./credentials.js";
+import { AuthenticationError, JpdclError, MutationDisabledError } from "./errors.js";
+import { basicAuth, buildUrl, CookieHttpClient } from "./http.js";
+import type { MainSession, PortalResponse, RequestOptions } from "./types.js";
+import { saveSession } from "./session.js";
+
+function truthyStatus(status: unknown): boolean {
+  return status === true || status === 1 || status === "1" || status === "true" || status === "Success" || status === "0";
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+export class JpdclClient {
+  private readonly http: CookieHttpClient;
+  private session?: MainSession;
+
+  constructor(
+    session?: MainSession,
+    private readonly baseUrl = MAIN_API_URL,
+    private readonly allowMutations = mutationsEnabled(),
+    private readonly suppliedCredentials?: Credentials,
+    private readonly persistSession: (session: MainSession) => Promise<void> = saveSession,
+  ) {
+    this.session = session;
+    this.http = new CookieHttpClient(session?.cookies);
+  }
+
+  get currentSession(): MainSession | undefined {
+    if (!this.session) return undefined;
+    return { ...this.session, cookies: this.http.serialize(), updatedAt: new Date().toISOString() };
+  }
+
+  async login(loginId: string, password: string): Promise<PortalResponse> {
+    if (!loginId || !password) throw new AuthenticationError("Login ID and password are required");
+    const response = await this.http.fetch(buildUrl(this.baseUrl, "/userLoginWebNew"), {
+      method: "GET",
+      headers: {
+        Accept: "application/json, text/plain, */*",
+        Authorization: basicAuth(PORTAL_BASIC),
+        [LOGIN_CREDENTIAL_HEADER]: Buffer.from(`${loginId}:${password}`, "utf8").toString("base64"),
+      },
+    });
+    const decoded = await this.decodeResponse(response);
+    if (!response.ok || !truthyStatus(decoded.status)) {
+      throw new AuthenticationError(decoded.message ?? `Login failed with HTTP ${response.status}`, decoded);
+    }
+
+    const data = asRecord(decoded.data) ?? {};
+    const now = new Date().toISOString();
+    this.session = {
+      version: 1,
+      createdAt: now,
+      updatedAt: now,
+      cookies: this.http.serialize(),
+      loginId: String(data.login_id ?? loginId),
+      primaryAccountId: data.primary_acc_number ? String(data.primary_acc_number) : undefined,
+      user: data,
+    };
+    return decoded;
+  }
+
+  async request<T = unknown>(name: EndpointName | string, options: RequestOptions = {}): Promise<PortalResponse<T>> {
+    return this.requestInternal<T>(name, options, false);
+  }
+
+  private async requestInternal<T>(name: EndpointName | string, options: RequestOptions, retriedAuthentication: boolean): Promise<PortalResponse<T>> {
+    if (!isEndpointName(name)) throw new JpdclError(`Unknown endpoint: ${name}`, 400);
+    const endpoint = endpointCatalog[name];
+    if (endpoint.portal !== "main") throw new JpdclError(`${name} belongs to the smart-meter portal`, 400);
+    if (endpoint.mutation && !this.allowMutations) throw new MutationDisabledError();
+    if (name === "main_login") throw new JpdclError("Use login() for consumer authentication", 400);
+    if (endpoint.auth === "main-session" && !this.session) throw new AuthenticationError();
+
+    const url = buildUrl(this.baseUrl, endpoint.path, options.params);
+    const headers: Record<string, string> = {
+      Accept: "application/json, text/plain, */*",
+      ...options.headers,
+    };
+    if (endpoint.auth === "public-basic" || endpoint.auth === "external-basic") {
+      headers.Authorization = basicAuth(PORTAL_BASIC);
+    }
+
+    let body: string | undefined;
+    if (endpoint.method !== "GET" && endpoint.method !== "DELETE") {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(endpoint.encrypted === false ? (options.body ?? {}) : encryptPayload(options.body ?? {}));
+    }
+
+    const response = await this.http.fetch(url, { method: endpoint.method, headers, body });
+    const decoded = await this.decodeResponse<T>(response);
+    if (!retriedAuthentication && endpoint.auth === "main-session" && isAuthenticationFailure(response.status, decoded)) {
+      const credentials = this.suppliedCredentials ?? await resolveCredentials();
+      if (credentials) {
+        const smartSession = this.session?.smart;
+        await this.login(credentials.loginId, credentials.password);
+        if (this.session && smartSession) this.session.smart = smartSession;
+        const refreshedSession = this.currentSession;
+        if (refreshedSession) await this.persistSession(refreshedSession);
+        return this.requestInternal<T>(name, options, true);
+      }
+    }
+    if (!response.ok) throw new JpdclError(decoded.message ?? `JPDCL returned HTTP ${response.status}`, response.status, decoded);
+    return decoded;
+  }
+
+  private async decodeResponse<T = unknown>(response: Response): Promise<PortalResponse<T>> {
+    const text = await response.text();
+    if (!text) return { status: response.ok };
+    try {
+      return decryptPayload<PortalResponse<T>>(text);
+    } catch (decryptError) {
+      try {
+        return JSON.parse(text) as PortalResponse<T>;
+      } catch {
+        throw new JpdclError("JPDCL returned an unreadable response", response.status, {
+          contentType: response.headers.get("content-type"),
+          decryptError: (decryptError as Error).message,
+        });
+      }
+    }
+  }
+
+  async customerInfo(accountId = this.session?.primaryAccountId): Promise<PortalResponse> {
+    if (!accountId) throw new JpdclError("An account ID is required", 400);
+    const result = await this.request("main_customer_info", { body: { accountid: accountId } });
+    const record = asRecord(result.data);
+    if (record && this.session) {
+      this.session.consumerCode = record.consumerID ? String(record.consumerID) : this.session.consumerCode;
+    }
+    return result;
+  }
+
+  async linkedAccounts(loginId = this.session?.loginId): Promise<PortalResponse> {
+    if (!loginId) throw new JpdclError("A login ID is required", 400);
+    return this.request("main_linked_accounts", { body: { loginid: loginId } });
+  }
+
+  async history(
+    type: "BILL" | "PAYM",
+    accountId = this.session?.primaryAccountId,
+    from = sixMonthsAgo(),
+    to = isoDate(new Date()),
+  ): Promise<PortalResponse> {
+    if (!accountId) throw new JpdclError("An account ID is required", 400);
+    assertDateRange(from, to, { requireBoth: true });
+    return this.request("main_bill_history", {
+      body: { acct_id: accountId, type, st_dt: from, en_dt: to },
+    });
+  }
+
+  async consumption(
+    accountId = this.session?.primaryAccountId,
+    from = sixMonthsAgo(),
+    to = isoDate(new Date()),
+  ): Promise<PortalResponse> {
+    if (!accountId) throw new JpdclError("An account ID is required", 400);
+    assertDateRange(from, to, { requireBoth: true });
+    return this.request("main_consumption", {
+      body: { accountid: accountId, fromdate: from, todate: to },
+    });
+  }
+
+  async smartSso(accountId: string, meterNumber: string): Promise<PortalResponse> {
+    return this.request("main_smart_sso", { body: { accountId, mtrno: meterNumber } });
+  }
+
+  async digest(accountId = this.session?.primaryAccountId): Promise<Record<string, unknown>> {
+    if (!accountId) throw new JpdclError("An account ID is required", 400);
+    const customer = await this.customerInfo(accountId);
+    const optional = await Promise.all([
+      capturePortal("bills", this.history("BILL", accountId)),
+      capturePortal("payments", this.history("PAYM", accountId)),
+      capturePortal("consumption", this.consumption(accountId)),
+      capturePortal("linkedAccounts", this.linkedAccounts()),
+    ]);
+    const [bills, payments, consumption, linked] = optional;
+    const customerData = asRecord(customer.data) ?? {};
+    return {
+      _meta: {
+        dataClass: "observed-account-and-billing-records",
+        source: "jpdcl-wss",
+        sourceErrors: optional.filter((result) => !result.ok).map((result) => ({ source: result.source, message: result.error })),
+      },
+      generatedAt: new Date().toISOString(),
+      accountId,
+      consumer: customerData,
+      currentBill: customerData.billDetails ?? customerData.currentBill ?? null,
+      meter: {
+        number: customerData.mtrSrNum ?? customerData.meterNo ?? customerData.meterNumber,
+        accountType: customerData.postOrPre ?? customerData.accountType,
+        netMetering: customerData.isNetMtrAcct,
+      },
+      bills: bills.ok ? bills.value.data ?? [] : [],
+      payments: payments.ok ? payments.value.data ?? [] : [],
+      consumption: consumption.ok ? consumption.value.data ?? [] : [],
+      linkedAccounts: linked.ok ? linked.value.data ?? [] : [],
+    };
+  }
+}
+
+async function capturePortal(source: string, promise: Promise<PortalResponse>): Promise<
+  { ok: true; source: string; value: PortalResponse } | { ok: false; source: string; error: string }
+> {
+  try { return { ok: true, source, value: await promise }; }
+  catch (error) { return { ok: false, source, error: error instanceof Error ? error.message : String(error) }; }
+}
+
+function isAuthenticationFailure(httpStatus: number, response: PortalResponse): boolean {
+  if (httpStatus === 401 || httpStatus === 403) return true;
+  const message = String(response.message ?? "").toLowerCase();
+  return ["unauthor", "session expired", "login again", "not authenticated"].some((marker) => message.includes(marker));
+}
+
+export function isoDate(date: Date): string {
+  return date.toISOString().slice(0, 10);
+}
+
+export function sixMonthsAgo(): string {
+  const date = new Date();
+  date.setMonth(date.getMonth() - 6);
+  return isoDate(date);
+}

package/src/mcp-stdio.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createJpdclMcpServer } from "./mcp.js";
+
+const server = await createJpdclMcpServer();
+await server.connect(new StdioServerTransport());