@getpeppr/cli 0.7.1 → 0.8.1

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to `@getpeppr/cli` are documented here.
 
 The CLI bundles `@getpeppr/sdk` into its published artifact (tsup `noExternal`), so `validate`, `convert` and `init` run the SDK's validators, country rules and UBL builder locally — an SDK release only reaches CLI users once the CLI is rebundled. Rebundle-only releases are listed with the SDK version they ship.
 
+## [0.8.1] — 2026-08-19
+
+Republish of 0.8.0 with the actual code in the tarball. The 0.8.0 tarball on
+the registry shipped **without `dist/`** — three files, no binary — because
+this package had no `prepack`/`prepublishOnly` guards and was published from a
+tree where the bundle had never been built. 0.8.0 is deprecated on the
+registry; this version is identical in content and adds the guards so a
+dist-less publish can never happen again (`prepack` builds, `prepublishOnly`
+runs the tests, `pretest` builds first — the same arming the SDK has).
+
+## [0.8.0] — 2026-08-19
+
+**`getpeppr whoami`** — show the Peppol identity of the account behind your
+API key (GPR-1094). Environment, company, country, and every registered
+identifier with its status. Works with any key; `--prod`, `--local`, `--key`
+and `--json` behave as on `send` and `lookup`. No identity yet is an answer,
+not an error — the command points you at the console page where you set one up.
+
+Bundles SDK 4.3.0 (`peppol.identity.get()` — the API this command consumes).
+
 ## [0.7.1] — 2026-08-18
 
 Rebundle SDK 4.1.1. This release matters for `getpeppr validate`, which runs the

package/README.md

@@ -159,6 +159,30 @@ getpeppr send invoice.json --prod
 
 When sending through the API, getpeppr determines the seller from the API key. A `from` party can still be present for local validation and UBL conversion, but the gateway ignores it for delivery.
 
+### `getpeppr whoami` — Show your Peppol identity
+
+Read the Peppol identity of the account behind your API key: the environment the key operates in, your legal entity as the gateway holds it, and every Peppol identifier registered for it with its status. Works with **any** key — standard keys included. This is the fastest way to check "is my identifier registered and verified?" without opening the console.
+
+```bash
+# Sandbox identity (default)
+getpeppr whoami
+
+# Production identity (uses your live key)
+getpeppr whoami --prod
+
+# Machine-readable
+getpeppr whoami --json
+```
+
+| Flag | Description |
+|------|-------------|
+| `--prod` | Use the live API key (default: sandbox) |
+| `--local` | Target `http://localhost:3001` (dev server) |
+| `--key <key>` | Override API key. CI use only — visible in `ps`/shell history. Prefer `GETPEPPR_API_KEY`. |
+| `--json` | Output the identity as JSON |
+
+If no legal entity exists in the environment yet, `whoami` says so and points to the console page where you create one.
+
 ### `getpeppr logout` — Remove stored credentials
 
 ```bash
@@ -213,7 +237,7 @@ The CLI runs three validation engines from the [@getpeppr/sdk](https://www.npmjs
 2. **Business Rules** — Peppol BIS 3.0 / EN 16931 compliance (BR-xx, BR-CO-xx, PEPPOL-xx rules)
 3. **Country Rules** — Belgium (BE), France (FR), Italy (IT), Netherlands (NL), Germany (DE)
 
-Scaffolding (`init`), validation, and conversion run fully offline — no API key or network connection required. Only `lookup` and `send` need a network connection.
+Scaffolding (`init`), validation, and conversion run fully offline — no API key or network connection required. Only `lookup`, `send`, and `whoami` need a network connection.
 
 ## Invoice format
 

package/dist/index.js

@@ -1161,7 +1161,7 @@ function statusFamily(status) {
 var TERMINAL_FAILURE_STATUSES = STATUS_PRECEDENCE.filter((e) => e.family === "terminal-failure").map((e) => e.status);
 
 // ../sdk/dist/version.js
-var SDK_VERSION = "4.1.1";
+var SDK_VERSION = "4.3.0";
 
 // ../sdk/dist/core/client.js
 function findHeaderCaseInsensitive(headers, name) {
@@ -1713,6 +1713,10 @@ var GetpepprAdapter = class {
       expiresAt: String(result.expiresAt ?? "")
     };
   }
+  async getIdentity() {
+    const result = await this.request("GET", "/identity");
+    return parseAccountIdentity(result);
+  }
   async listBankAccounts(options) {
     const params = new URLSearchParams();
     if (options?.limit != null)
@@ -1871,6 +1875,14 @@ function parseSendResult(body) {
   if (typeof rulebook === "object" && rulebook !== null && typeof rulebook.peppol === "string" && typeof rulebook.verifiedAt === "string") {
     sendResult.rulebook = rulebook;
   }
+  const transmission = result.transmission;
+  if (typeof transmission === "object" && transmission !== null && !Array.isArray(transmission)) {
+    const mode = readOwn(transmission, "mode");
+    const bytePreservation = readOwn(transmission, "bytePreservation");
+    if (typeof mode === "string" && typeof bytePreservation === "string") {
+      sendResult.transmission = { mode, bytePreservation };
+    }
+  }
   const submissionId = optionalWireId(result.submissionId);
   if (submissionId)
     sendResult.submissionId = submissionId;
@@ -2012,6 +2024,74 @@ function parseLegalEntity(raw) {
   }
   return le;
 }
+function parseAccountIdentity(raw) {
+  const result = requireRecordBody(raw, "the identity request");
+  const environment = readOwn(result, "environment");
+  if (typeof environment !== "string" || environment.trim() === "") {
+    throw new PeppolProtocolError("The getpeppr API answered the identity request without an environment. The SDK will not invent one \u2014 please report this response to support@getpeppr.dev.", "environment", boundedBody(result));
+  }
+  const identifiersRaw = readOwn(result, "identifiers");
+  if (!Array.isArray(identifiersRaw)) {
+    throw new PeppolProtocolError("The getpeppr API answered the identity request without an identifiers array. The SDK will not invent one \u2014 please report this response to support@getpeppr.dev.", "identifiers", boundedBody(result));
+  }
+  const identifiers = identifiersRaw.map((row) => {
+    if (!isRecord(row)) {
+      throw new PeppolProtocolError("The getpeppr API answered the identity request with a malformed identifier row. Please report this response to support@getpeppr.dev.", "identifiers", boundedBody(result));
+    }
+    const scheme = readOwn(row, "scheme");
+    const value = readOwn(row, "value");
+    const status = readOwn(row, "status");
+    if (typeof scheme !== "string" || typeof value !== "string" || typeof status !== "string") {
+      throw new PeppolProtocolError("The getpeppr API answered the identity request with a malformed identifier row. Please report this response to support@getpeppr.dev.", "identifiers", boundedBody(result));
+    }
+    const createdAt = readOwn(row, "createdAt");
+    return {
+      scheme,
+      value,
+      status,
+      createdAt: typeof createdAt === "string" ? createdAt : null
+    };
+  });
+  return {
+    environment,
+    legalEntity: parseAccountIdentityLegalEntity(readOwn(result, "legalEntity"), result),
+    identifiers
+  };
+}
+function parseAccountIdentityLegalEntity(raw, body) {
+  if (raw === null)
+    return null;
+  if (!isRecord(raw)) {
+    throw new PeppolProtocolError(
+      "The getpeppr API answered the identity request without a valid legalEntity field. Please report this response to support@getpeppr.dev.",
+      "legalEntity",
+      // The FULL body, per the responseBody contract — `raw` alone serialises
+      // to the string "undefined" when the field is missing (2nd-pass gate N1).
+      boundedBody(body)
+    );
+  }
+  const companyName = readOwn(raw, "companyName");
+  const country = readOwn(raw, "country");
+  const createdAt = readOwn(raw, "createdAt");
+  return {
+    companyName: typeof companyName === "string" ? companyName : null,
+    country: typeof country === "string" ? country : null,
+    address: parseAccountIdentityAddress(readOwn(raw, "address")),
+    createdAt: typeof createdAt === "string" ? createdAt : null
+  };
+}
+function parseAccountIdentityAddress(raw) {
+  if (!isRecord(raw))
+    return null;
+  const line1 = readOwn(raw, "line1");
+  const city = readOwn(raw, "city");
+  const zip = readOwn(raw, "zip");
+  return {
+    line1: typeof line1 === "string" ? line1 : null,
+    city: typeof city === "string" ? city : null,
+    zip: typeof zip === "string" ? zip : null
+  };
+}
 function parseInvoiceSummary(row) {
   const raw = requireRecordBody(row, "this invoice row");
   const rawStatus = requireWireStatus(raw.state ?? raw.status, raw, "this invoice row");
@@ -2156,6 +2236,12 @@ var Peppol = class {
   contacts;
   bankAccounts;
   transports;
+  /**
+   * Your own account's Peppol identity — works with ANY key, standard keys
+   * included. `peppol.identity.get()` answers "who am I on the Peppol
+   * network?" for the account behind the key making the call.
+   */
+  identity;
   /**
    * Sub-tenant Legal Entities — **platform accounts only**.
    *
@@ -2163,8 +2249,9 @@ var Peppol = class {
    * every call here fails with 403 `master_key_required`.
    *
    * Onboarding your OWN company is not done through this API: your legal entity
-   * is managed in the console, on the Peppol identity page. This surface is for
-   * platforms that onboard their customers as sub-tenants.
+   * is managed in the console, on the Peppol identity page — and READ from the
+   * API with `peppol.identity.get()`, which works with any key. This surface is
+   * for platforms that onboard their customers as sub-tenants.
    *
    * **Getting access:** platform mode is enabled by getpeppr on your account —
    * email hello@getpeppr.dev to have it switched on. Once it is, you create the
@@ -2185,6 +2272,7 @@ var Peppol = class {
     this.contacts = new ContactOperations(this.adapter);
     this.bankAccounts = new BankAccountOperations(this.adapter);
     this.transports = new TransportOperations(this.adapter);
+    this.identity = new IdentityOperations(this.adapter);
     this.legalEntities = new LegalEntityOperations(this.adapter);
   }
   /**
@@ -2379,6 +2467,17 @@ ${validation.errors.map((e) => `  - ${e.field}: ${e.message}${e.suggestion ? ` (
    * **If you seal your documents, hash a canonical form (C14N) rather than the
    * raw bytes.**
    *
+   * The receipt says this itself, so your code need not rely on this comment:
+   * a successful import carries `transmission`, whose `bytePreservation` this
+   * gateway sets to `"not_guaranteed"` (GPR-1089). It is a guarantee we decline
+   * to give, not a claim that your document was altered.
+   *
+   * ⚠️ Read the value, do not assume it. This SDK talks to whatever gateway
+   * version you point it at: one predating GPR-1089 returns no `transmission`
+   * at all, and the field is typed `string` so a later value reaches you rather
+   * than being dropped. **Absent is not `false`** — it means the gateway did
+   * not say, never that your bytes are safe.
+   *
    * `to` is required and is never read from the document. Routing decides
    * delivery, the document travels as payload, and getpeppr will not guess a
    * destination by parsing your XML.
@@ -2772,6 +2871,34 @@ var ContactOperations = class {
     return paginate((offset, limit) => this.adapter.listContacts({ ...options, offset, limit }), options);
   }
 };
+var IdentityOperations = class {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Read the Peppol identity of your own account: the environment this key
+   * operates in, your legal entity as the gateway holds it, and the Peppol
+   * identifiers registered for it.
+   *
+   * Works with ANY API key — standard keys included; no platform mode or
+   * master key required. This is the read counterpart to onboarding: your
+   * legal entity is created and edited in the console (Peppol identity page)
+   * or via onboarding, and this call is how you READ it from the API.
+   *
+   * @example
+   * ```ts
+   * const me = await peppol.identity.get();
+   * console.log(me.environment, me.legalEntity?.companyName);
+   * for (const id of me.identifiers) {
+   *   console.log(`${id.scheme}:${id.value} — ${id.status}`);
+   * }
+   * ```
+   */
+  async get() {
+    return this.adapter.getIdentity();
+  }
+};
 var LegalEntityOperations = class {
   adapter;
   constructor(adapter) {
@@ -2785,7 +2912,8 @@ var LegalEntityOperations = class {
    * https://console.getpeppr.dev/api-keys.
    *
    * Your own company's legal entity is managed in the console, on the Peppol
-   * identity page; this creates an entity for a customer of yours.
+   * identity page (and read from the API with `peppol.identity.get()`); this
+   * creates an entity for a customer of yours.
    *
    * Idempotent on `externalId`: repeated calls with the same `externalId` return
    * the existing entity (HTTP 200) instead of creating a duplicate. Transient 5xx
@@ -4433,14 +4561,117 @@ function registerLoginCommand(program2) {
   });
 }
 
-// src/commands/logout.ts
+// src/commands/whoami.ts
 import pc8 from "picocolors";
+var API_BASE2 = "https://api.getpeppr.dev/v1";
+var LOCAL_BASE2 = "http://localhost:3001/api/v1";
+var PEPPOL_IDENTITY_URL = "https://console.getpeppr.dev/peppol-identity";
+function sanitizeTerminal(s) {
+  return s.replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+}
+function formatIdentity(identity) {
+  const lines = [];
+  lines.push(
+    `  ${pc8.dim("Environment")}  ${sanitizeTerminal(identity.environment)}`
+  );
+  const le = identity.legalEntity;
+  if (!le) {
+    lines.push("");
+    lines.push(
+      `${pc8.yellow("!")} No Peppol identity in this environment yet.`
+    );
+    lines.push(
+      `  Create your legal entity in the console: ${PEPPOL_IDENTITY_URL}`
+    );
+    return lines.join("\n");
+  }
+  lines.unshift(
+    `${pc8.green("\u2713")} ${le.companyName != null ? sanitizeTerminal(le.companyName) : pc8.dim("(no company name)")}`
+  );
+  if (le.country) {
+    lines.push(
+      `  ${pc8.dim("Country")}      ${sanitizeTerminal(countryLabel(le.country))}`
+    );
+  }
+  if (le.address) {
+    const parts = [le.address.line1, le.address.zip, le.address.city].filter((p) => Boolean(p)).map(sanitizeTerminal);
+    if (parts.length > 0) {
+      lines.push(`  ${pc8.dim("Address")}      ${parts.join(", ")}`);
+    }
+  }
+  if (le.createdAt) {
+    lines.push(`  ${pc8.dim("Created")}      ${sanitizeTerminal(le.createdAt)}`);
+  }
+  lines.push("");
+  if (identity.identifiers.length === 0) {
+    lines.push(
+      `${pc8.dim("No identifiers registered yet.")} Register one in the console: ${PEPPOL_IDENTITY_URL}`
+    );
+    return lines.join("\n");
+  }
+  const plural = identity.identifiers.length === 1 ? "identifier" : "identifiers";
+  lines.push(`${identity.identifiers.length} Peppol ${plural}:`);
+  const rows = identity.identifiers.map((id) => ({
+    peppolId: sanitizeTerminal(`${id.scheme}:${id.value}`),
+    status: sanitizeTerminal(id.status),
+    createdAt: id.createdAt ? sanitizeTerminal(id.createdAt) : null
+  }));
+  const idW = Math.max(...rows.map((r) => r.peppolId.length)) + 3;
+  const statusW = Math.max(...rows.map((r) => r.status.length)) + 3;
+  for (const row of rows) {
+    const line = `  ${row.peppolId.padEnd(idW)}${row.status.padEnd(statusW)}${row.createdAt ? pc8.dim(row.createdAt) : ""}`;
+    lines.push(line.trimEnd());
+  }
+  return lines.join("\n");
+}
+function registerWhoamiCommand(program2) {
+  program2.command("whoami").description("Show the Peppol identity of the account behind your API key").option("--prod", "use the live API key (default: sandbox)").option("--local", "target localhost:3001 dev server").option(
+    "--key <key>",
+    "override API key \u2014 for CI/scripted use only; visible in `ps` and shell history. Prefer GETPEPPR_API_KEY env var."
+  ).option("--json", "output the identity as JSON").action(async (flags) => {
+    let auth;
+    try {
+      auth = resolveApiKey({
+        flagKey: flags.key,
+        forceProd: Boolean(flags.prod),
+        forceLocal: Boolean(flags.local)
+      });
+    } catch (e) {
+      if (e instanceof AuthError) {
+        exitWithError(e.message);
+        return;
+      }
+      throw e;
+    }
+    const baseUrl = flags.local ? LOCAL_BASE2 : API_BASE2;
+    const client = new Peppol({ apiKey: auth.apiKey, baseUrl });
+    let identity;
+    try {
+      identity = await client.identity.get();
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`${pc8.red("\u2717")} ${sanitizeTerminal(msg)}
+`);
+      process.exit(1);
+      return;
+    }
+    if (flags.json) {
+      console.log(JSON.stringify(identity, null, 2));
+    } else {
+      console.log(formatIdentity(identity));
+    }
+    process.exitCode = 0;
+  });
+}
+
+// src/commands/logout.ts
+import pc9 from "picocolors";
 function registerLogoutCommand(program2) {
   program2.command("logout").description("Remove ~/.config/getpeppr/credentials.json").action(() => {
     const path = getCredentialsPath();
     const removed = deleteCredentials();
     if (removed) {
-      process.stderr.write(`${pc8.green("\u2713")} Removed ${path}
+      process.stderr.write(`${pc9.green("\u2713")} Removed ${path}
 `);
     } else {
       process.stderr.write(`No credentials to remove (${path})
@@ -4461,6 +4692,7 @@ registerConvertCommand(program);
 registerLookupCommand(program);
 registerSendCommand(program);
 registerLoginCommand(program);
+registerWhoamiCommand(program);
 registerLogoutCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map