pakstr 0.9.0 → 0.11.0

package/dist/cli.js

@@ -32,7 +32,7 @@ async function runCLI(argv) {
     const configFlag = extractFlag(args, "--config");
     switch (command) {
         case "init":
-            (0, init_1.initCommand)({ force: args.includes("--force"), out: configFlag });
+            await (0, init_1.initCommand)({ force: args.includes("--force"), out: configFlag });
             return;
         case "build":
             await (0, build_1.buildCommand)(configFlag ?? undefined);

package/dist/commands/init.js

@@ -23,7 +23,7 @@ const HEADER = `# pakstr.yaml — one file, one command, one APK.
 # has it can derive every app identity for every known appId. Losing it breaks
 # update continuity. It cannot rotate the signer of an already-published app.
 `;
-function initCommand(options = {}) {
+async function initCommand(options = {}) {
     const configPath = path_1.default.resolve(options.out ?? path_1.default.join(process.cwd(), pakstrConfig_1.PAKSTR_CONFIG_FILENAME));
     if (fs_1.default.existsSync(configPath) && !options.force) {
         throw new Error(`${configPath} already exists. Use --force to overwrite, or remove it first.`);
@@ -53,8 +53,12 @@ function initCommand(options = {}) {
     }
     // Generate a fresh dev nsec into a gitignored `.env` so `pakstr run` works
     // locally with no manual setup. Never overwrites an existing PAKSTR_NSEC.
-    const nsecStatus = ensureDevNsec();
-    ensureGitIgnoresEnv();
+    const configDir = path_1.default.dirname(configPath);
+    const { nsec: devNsec, status: nsecStatus } = ensureDevNsec(configDir);
+    ensureGitIgnoresEnv(configDir);
+    // Write zapstore.yaml (relay-side publisher whitelist) with the publisher
+    // npub derived from the dev nsec. Never overwrites an existing one.
+    const zapstoreStatus = await ensureZapstoreYaml(devNsec, configDir);
     console.log("");
     console.log("➡️  Next: run pakstr run");
     if (nsecStatus === "generated") {
@@ -63,34 +67,42 @@ function initCommand(options = {}) {
     else if (nsecStatus === "present") {
         console.log(`    ${nostr_1.PAKSTR_NSEC_ENV} already in .env — left untouched.`);
     }
+    if (zapstoreStatus === "generated") {
+        console.log("    zapstore.yaml written (relay-side publisher whitelist). Commit it.");
+    }
+    else if (zapstoreStatus === "present") {
+        console.log("    zapstore.yaml already exists — left untouched.");
+    }
     console.log("");
     console.log(`    For real releases, put the SAME ${nostr_1.PAKSTR_NSEC_ENV} in your CI secret manager`);
     console.log("    (reusing it is what lets an update install over the previous APK).");
     console.log(`    ${nostr_1.PAKSTR_NSEC_ENV} is a release-signing root secret: anyone who has it can`);
     console.log("    sign updates for every app whose appId they know. Keep it safe.");
 }
-/** Generate a dev nsec into .env if none is present there. Returns what happened. */
-function ensureDevNsec() {
-    const envPath = path_1.default.join(process.cwd(), ".env");
+/** Generate a dev nsec into .env if none is present there. Returns the nsec string. */
+function ensureDevNsec(dir) {
+    const envPath = path_1.default.join(dir, ".env");
     const existing = fs_1.default.existsSync(envPath)
         ? fs_1.default.readFileSync(envPath, "utf8")
         : "";
-    if (containsPakstrNsec(existing))
-        return "present";
+    if (containsPakstrNsec(existing)) {
+        const m = existing.match(new RegExp(`^${nostr_1.PAKSTR_NSEC_ENV}=(\\S+)`, "m"));
+        return { nsec: m?.[1] ?? "", status: "present" };
+    }
     const nsec = (0, nostr_1.encodeNsec)((0, crypto_1.randomBytes)(32));
     const line = `${nostr_1.PAKSTR_NSEC_ENV}=${nsec}\n`;
     const header = existing.length === 0 ? "# Local development secrets — never commit this file.\n" : "";
     fs_1.default.writeFileSync(envPath, header + (existing.length ? "\n" + line : line), {
         flag: existing.length === 0 ? "wx" : "a",
     });
-    return "generated";
+    return { nsec, status: "generated" };
 }
 function containsPakstrNsec(envText) {
     return new RegExp(`^${nostr_1.PAKSTR_NSEC_ENV}=`, "m").test(envText);
 }
 /** Ensure `.env` is listed in `.gitignore` so the nsec is never committed. */
-function ensureGitIgnoresEnv() {
-    const gitignorePath = path_1.default.join(process.cwd(), ".gitignore");
+function ensureGitIgnoresEnv(dir) {
+    const gitignorePath = path_1.default.join(dir, ".gitignore");
     const existing = fs_1.default.existsSync(gitignorePath)
         ? fs_1.default.readFileSync(gitignorePath, "utf8")
         : "";
@@ -106,7 +118,48 @@ function ensureGitIgnoresEnv() {
 function containsEnvEntry(gitignoreText) {
     return gitignoreText
         .split(/\r?\n/)
-        .some(line => line.trim() === ".env" || line.trim().startsWith(".env"));
+        .some(line => {
+        const t = line.trim();
+        return t === ".env" || t.startsWith(".env/");
+    });
+}
+/**
+ * Write `zapstore.yaml` (relay-side publisher whitelist) with the publisher
+ * npub derived from the dev nsec. Never overwrites an existing file.
+ * Returns what happened.
+ */
+async function ensureZapstoreYaml(devNsec, dir) {
+    const zapstorePath = path_1.default.join(dir, "zapstore.yaml");
+    if (fs_1.default.existsSync(zapstorePath))
+        return "present";
+    let npub = "";
+    if (devNsec) {
+        try {
+            const secret = (0, nostr_1.decodeNsec)(devNsec);
+            const hex = await (0, nostr_1.getNpubHex)(secret);
+            npub = (0, nostr_1.pubkeyHexToNpub)(hex);
+        }
+        catch {
+            // If we can't derive the npub, write the file with a placeholder so the
+            // user knows to fill it in.
+            npub = "";
+        }
+    }
+    const content = `# zapstore.yaml — relay-side publisher whitelist (NIP-82 / Zap Store).
+# The relay fetches this file from your repo to verify the publisher's pubkey
+# is authorized for this repository. Generated by \`pakstr init\` (never
+# overwritten on re-runs; remove this file first if you need a fresh one).
+#
+# \`pubkey\` is the npub matching the nsec used to publish (PAKSTR_NSEC, or
+# PAKSTR_PUBLISH_NSEC if you set publish.publishKey). Replace it with your
+# real publisher npub for production releases if different from your dev nsec.
+# Note: write access to this repo grants publish authority — protect branch access.
+
+repository: # Set to your app's source code repository URL (e.g. https://github.com/org/app)
+pubkey: ${npub || "# Set to your publisher npub (npub1...)"}
+`;
+    fs_1.default.writeFileSync(zapstorePath, content, "utf8");
+    return "generated";
 }
 function renderConfig(c) {
     const perms = `    [${pakstrConfig_1.PERMISSION_ALIASES.map(p => `"${p}"`).join(", ")}]`;

package/dist/commands/publish.js

@@ -9,6 +9,8 @@ const path_1 = __importDefault(require("path"));
 const pakstrConfig_1 = require("../core/pakstrConfig");
 const zapStore_1 = require("../core/zapStore");
 const blossom_1 = require("../core/blossom");
+const nostr_1 = require("../core/nostr");
+const identityProof_1 = require("../core/identityProof");
 /**
  * `pakstr publish` — upload the signed APK to Blossom and publish NIP-82
  * events (32267/30063/3063) to the configured relay. Spec §5.4 / §8.
@@ -34,6 +36,7 @@ async function publishCommand(configPath, options = {}) {
     let apkSize;
     let signerCertificateSha256;
     let filename;
+    let identityProof;
     if (options.dryRun) {
         // No network, no APK required. Synthesize a stub descriptor so the events
         // can still be built and printed for preview.
@@ -42,6 +45,14 @@ async function publishCommand(configPath, options = {}) {
         blossomUrl = `${config.publish.blossom.replace(/\/$/, "")}/${apkSha256}`;
         signerCertificateSha256 = "0".repeat(64);
         filename = path_1.default.basename(apkPath);
+        // Stub identity proof so the 30509 event path is exercised end-to-end.
+        identityProof = {
+            certHash: signerCertificateSha256,
+            signature: "dry-run-stub==",
+            createdAt: Math.floor(Date.now() / 1000),
+            expiry: Math.floor(Date.now() / 1000) + 365 * 24 * 3600,
+            pubkeyHex: await (0, nostr_1.getNpubHex)(publishNsec.bytes),
+        };
         console.log("📦 (dry-run) Blossom URL:", blossomUrl);
     }
     else {
@@ -53,6 +64,25 @@ async function publishCommand(configPath, options = {}) {
             throw new Error(`Signer certificate sidecar not found: ${certShaPath}. Run \`pakstr sign\` first.`);
         }
         signerCertificateSha256 = fs_1.default.readFileSync(certShaPath, "utf8").trim();
+        // Read the NIP-C1 identity proof sidecar (optional; generated by
+        // `pakstr sign` when a publish nsec is available).
+        const proofPath = `${apkPath}.identity-proof`;
+        if (fs_1.default.existsSync(proofPath)) {
+            let raw;
+            try {
+                raw = fs_1.default.readFileSync(proofPath, "utf8").trim();
+            }
+            catch (e) {
+                throw new Error(`Failed to read identity proof sidecar ${proofPath}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            identityProof = (0, identityProof_1.parseIdentityProofSidecar)(raw, proofPath, signerCertificateSha256);
+        }
+        else {
+            // No sidecar found — warn so users can spot a missing 30509 proof
+            // in CI output (the sign step may have run without a publish nsec).
+            console.log("⚠️  No .identity-proof sidecar found — the kind 30509 identity proof will not be published.");
+            console.log("    Re-run \`pakstr sign\` with a publish nsec available to generate it.");
+        }
         const blossom = await (0, blossom_1.uploadToBlossom)({
             serverUrl: config.publish.blossom,
             filePath: apkPath,
@@ -85,12 +115,16 @@ async function publishCommand(configPath, options = {}) {
         },
         publishNsec,
         target: { relayUrl: config.publish.relay },
+        identityProof,
     }, transport);
     console.log(options.dryRun ? "✅ PUBLISHED (dry-run — no network)" : "✅ PUBLISHED");
     console.log("🪪 Publisher npub:", result.npub);
     console.log("🧾 Asset event:", result.assetEventId);
     console.log("🧾 Release event:", result.releaseEventId);
     console.log("🧾 App metadata event:", result.appMetadataEventId);
+    if (result.identityProofEventId) {
+        console.log("🧾 Identity proof event:", result.identityProofEventId);
+    }
     console.log("🔗 Blossom URL:", blossomUrl);
     console.log("📡 Relay:", config.publish.relay);
     if (options.verify && !options.dryRun) {
@@ -127,6 +161,7 @@ async function publishCommand(configPath, options = {}) {
             assetEventId: result.assetEventId,
             releaseEventId: result.releaseEventId,
             appMetadataEventId: result.appMetadataEventId,
+            identityProofEventId: result.identityProofEventId,
             publishedAt: new Date().toISOString(),
             dryRun: !!options.dryRun,
         };

package/dist/commands/sign.js

@@ -21,6 +21,21 @@ async function signCommand(configPath) {
         throw new Error(`Unsigned APK not found at ${unsignedApkPath}. Run \`pakstr build\` first.`);
     }
     const nsec = (0, nostr_1.requireSigningNsec)(process.env);
+    // Resolve the publish nsec to derive the publisher pubkey for the NIP-C1
+    // identity proof (kind 30509). If publishing is disabled, skip the proof.
+    let identityProofPubkey;
+    if (config.publish.zapstoreEnabled) {
+        try {
+            const pubNsec = (0, nostr_1.resolvePublishNsec)(config.publish.publishKey, process.env);
+            identityProofPubkey = await (0, nostr_1.getNpubHex)(pubNsec.bytes);
+        }
+        catch (e) {
+            // If the publish nsec isn't available yet, skip the identity proof
+            // but warn so the user knows it was skipped (not silently dropped).
+            console.log(`⚠️  NIP-C1 identity proof skipped: publish nsec not available (${e instanceof Error ? e.message : String(e)}).`);
+            console.log(`    Re-run \`pakstr sign\` once the publish nsec is set to generate the 30509 proof.`);
+        }
+    }
     console.log("\n🔐 pakstr sign");
     console.log("📦 Unsigned:", unsignedApkPath);
     console.log("🔑 Deriving signing key from PAKSTR_NSEC +", config.app.appId);
@@ -30,10 +45,23 @@ async function signCommand(configPath) {
         signedApkPath: unsignedApkPath,
         appId: config.app.appId,
         nsec: nsec.bytes,
+        identityProofPubkey,
     });
     // Write the signer certificate SHA-256 to a sidecar so `pakstr publish`/`run`
     // can include it in the Zap Store asset event (apk_certificate_hash).
     fs_1.default.writeFileSync(`${unsignedApkPath}.signer-sha256`, result.signerSha256, "utf8");
+    // Write the NIP-C1 identity proof to a sidecar so `pakstr publish`/`run`
+    // can include it as a kind 30509 event. If no proof was produced
+    // (e.g. publish nsec not available), clean up any stale sidecar from
+    // a previous sign run so publish doesn't emit a stale 30509 event.
+    const proofSidecarPath = `${unsignedApkPath}.identity-proof`;
+    if (result.identityProof) {
+        fs_1.default.writeFileSync(proofSidecarPath, JSON.stringify(result.identityProof), "utf8");
+        console.log("🧾 NIP-C1 identity proof generated (kind 30509)");
+    }
+    else {
+        fs_1.default.rmSync(proofSidecarPath, { force: true });
+    }
     console.log("✅ SIGNED");
     console.log("📦 Signed APK:", result.signedApkPath);
     console.log("🧾 Signer certificate SHA-256:", result.signerSha256);

package/dist/core/identityProof.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIdentityProofSidecar = parseIdentityProofSidecar;
+/**
+ * Validate and parse an identity proof from a raw JSON string (the
+ * `.identity-proof` sidecar). Throws on any malformed input.
+ *
+ * @param raw - the raw file content (JSON)
+ * @param proofPath - for error messages
+ * @param signerCertSha256 - the expected cert hash (from `.signer-sha256`)
+ * @returns the validated IdentityProof
+ */
+function parseIdentityProofSidecar(raw, proofPath, signerCertSha256) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`Identity proof sidecar ${proofPath} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const p = parsed;
+    const certHash = typeof p?.certHash === "string" ? p.certHash : undefined;
+    const signature = typeof p?.signature === "string" ? p.signature : undefined;
+    const createdAt = typeof p?.createdAt === "number" ? p.createdAt : undefined;
+    const expiry = typeof p?.expiry === "number" ? p.expiry : undefined;
+    const pubkeyHex = typeof p?.pubkeyHex === "string" ? p.pubkeyHex : undefined;
+    if (!certHash || !/^[0-9a-f]{64}$/.test(certHash)) {
+        throw new Error(`Identity proof sidecar ${proofPath} has an invalid certHash (expected 64 lowercase hex chars)`);
+    }
+    if (!signature || !/^[A-Za-z0-9+/]+={0,2}$/.test(signature) || signature.length % 4 !== 0) {
+        throw new Error(`Identity proof sidecar ${proofPath} has an invalid signature (expected valid base64)`);
+    }
+    if (!pubkeyHex || !/^[0-9a-f]{64}$/.test(pubkeyHex)) {
+        throw new Error(`Identity proof sidecar ${proofPath} has an invalid pubkeyHex (expected 64 lowercase hex chars)`);
+    }
+    if (typeof createdAt !== "number" || typeof expiry !== "number" || expiry <= createdAt) {
+        throw new Error(`Identity proof sidecar ${proofPath} has invalid timestamps (createdAt=${createdAt}, expiry=${expiry})`);
+    }
+    if (createdAt > Math.floor(Date.now() / 1000) + 300) {
+        throw new Error(`Identity proof sidecar ${proofPath} has a createdAt too far in the future (createdAt=${createdAt}) — possible tampering`);
+    }
+    if (expiry < Math.floor(Date.now() / 1000)) {
+        throw new Error(`Identity proof sidecar ${proofPath} has expired (expiry=${expiry})`);
+    }
+    if (certHash !== signerCertSha256) {
+        throw new Error(`Identity proof certHash does not match the APK signer certificate: ${certHash} vs ${signerCertSha256}`);
+    }
+    return { certHash, signature, createdAt, expiry, pubkeyHex };
+}

package/dist/core/zapStore.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockRelayTransport = exports.WebsocketRelayTransport = exports.KIND_ASSET = exports.KIND_RELEASE = exports.KIND_APP_METADATA = exports.DEFAULT_COMMUNITY = void 0;
+exports.MockRelayTransport = exports.WebsocketRelayTransport = exports.IDENTITY_PROOF_MESSAGE = exports.KIND_IDENTITY_PROOF = exports.KIND_ASSET = exports.KIND_RELEASE = exports.KIND_APP_METADATA = exports.DEFAULT_COMMUNITY = void 0;
+exports.formatIdentityProofMessage = formatIdentityProofMessage;
 exports.buildSignedPublishEvents = buildSignedPublishEvents;
 exports.publishToZapStore = publishToZapStore;
 exports.resolvePublishSecret = resolvePublishSecret;
@@ -14,11 +15,29 @@ exports.DEFAULT_COMMUNITY = "acfeaea6e51420e8068fac446ca9d17d7a9ef6a5d20d93894e5
 exports.KIND_APP_METADATA = 32267;
 exports.KIND_RELEASE = 30063;
 exports.KIND_ASSET = 3063;
+/** NIP-C1: Cryptographic Identity Proof (SPKI). Links the APK signing
+ * certificate to the publisher Nostr identity. */
+exports.KIND_IDENTITY_PROOF = 30509;
+/**
+ * The NIP-C1 signed message format. This MUST be byte-for-byte
+ * identical to the Java constant in DeterministicSigningTool.java
+ * (IDENTITY_PROOF_MESSAGE). Any whitespace/wording difference breaks
+ * signature verification.
+ */
+exports.IDENTITY_PROOF_MESSAGE = "Verifying at %d until %d that I control the following Nostr public key: %s";
+/** Build the NIP-C1 message from the proof fields. */
+function formatIdentityProofMessage(createdAt, expiry, pubkeyHex) {
+    return exports.IDENTITY_PROOF_MESSAGE
+        .replace("%d", String(createdAt))
+        .replace("%d", String(expiry))
+        .replace("%s", pubkeyHex);
+}
 /** Android platform identifier for the template's generic APK. */
 const PLATFORM = "android-arm64-v8a";
 const MIN_SDK = 28;
 const TARGET_SDK = 36;
-/** Build the three NIP-82 events (unsigned → signed) for an app release. */
+/** Build the NIP-82 events (unsigned → signed) for an app release.
+ * Includes a NIP-C1 identity proof (kind 30509) if `identityProof` is set. */
 async function buildSignedPublishEvents(input) {
     const pubkeyHex = await (0, nostr_1.getNpubHex)(input.publishNsec.bytes);
     const npub = (0, nostr_1.pubkeyHexToNpub)(pubkeyHex);
@@ -70,7 +89,30 @@ async function buildSignedPublishEvents(input) {
         ],
         content: "",
     }, input.publishNsec.bytes);
-    return { npub, pubkeyHex, appMetadata, release, asset };
+    // kind 30509 — NIP-C1 Identity Proof (optional, links the APK signing
+    // certificate to the publisher Nostr identity). The signature is produced
+    // by the Java DeterministicSigningTool using the derived P-256 key.
+    let identityProofEvent;
+    if (input.identityProof) {
+        // The proof binds the APK signing cert to a specific Nostr pubkey.
+        // If the publish nsec changed between sign and publish, the content would
+        // carry a different pubkey than what was signed — the proof would be invalid.
+        if (input.identityProof.pubkeyHex !== pubkeyHex) {
+            throw new Error(`NIP-C1 identity proof is bound to pubkey ${input.identityProof.pubkeyHex} but the current publish nsec's pubkey is ${pubkeyHex}. Re-run \`pakstr sign\` with the current publish nsec to regenerate the proof.`);
+        }
+        identityProofEvent = await (0, nostr_1.signNostrEvent)({
+            kind: exports.KIND_IDENTITY_PROOF,
+            created_at: input.identityProof.createdAt,
+            tags: [
+                ["d", input.identityProof.certHash],
+                ["signature", input.identityProof.signature],
+                ["expiry", String(input.identityProof.expiry)],
+            ],
+            // Use the proof's pubkeyHex (matches what the P-256 key signed).
+            content: formatIdentityProofMessage(input.identityProof.createdAt, input.identityProof.expiry, input.identityProof.pubkeyHex),
+        }, input.publishNsec.bytes);
+    }
+    return { npub, pubkeyHex, appMetadata, release, asset, identityProof: identityProofEvent ?? undefined };
 }
 /** Publish all three events to the relay via the given transport. */
 async function publishToZapStore(input, transport) {
@@ -78,16 +120,21 @@ async function publishToZapStore(input, transport) {
     await transport.publish(built.asset, input.target.relayUrl);
     await transport.publish(built.release, input.target.relayUrl);
     await transport.publish(built.appMetadata, input.target.relayUrl);
+    if (built.identityProof) {
+        await transport.publish(built.identityProof, input.target.relayUrl);
+    }
     return {
         npub: built.npub,
         pubkeyHex: built.pubkeyHex,
         appMetadataEventId: built.appMetadata.id,
         releaseEventId: built.release.id,
         assetEventId: built.asset.id,
+        identityProofEventId: built.identityProof?.id,
         events: {
             appMetadata: built.appMetadata,
             release: built.release,
             asset: built.asset,
+            identityProof: built.identityProof,
         },
         relayUrl: input.target.relayUrl,
     };

package/dist/runners/DockerSignRunner.js

@@ -41,9 +41,15 @@ class DockerSignRunner {
                 APP_NSEC: nsecString,
                 KEYSTORE_PASSWORD: password,
             };
-            // Explicitly forward the two signing env vars into the container; docker
+            if (request.identityProofPubkey) {
+                env.IDENTITY_PROOF_PUBKEY = request.identityProofPubkey.toLowerCase();
+            }
+            // Explicitly forward the signing env vars into the container; docker
             // run does not auto-forward the parent environment.
             const signingEnvNames = ["APP_NSEC", "KEYSTORE_PASSWORD"];
+            if (request.identityProofPubkey) {
+                signingEnvNames.push("IDENTITY_PROOF_PUBKEY");
+            }
             const stdout = this.execute("docker", [
                 "run",
                 "--rm",
@@ -61,6 +67,21 @@ class DockerSignRunner {
                 "/out/signed.apk",
             ], { env, secrets: [nsecString, password], streamOutput: true }).stdout;
             const signerSha256 = parseSignerSha(stdout);
+            const identityProof = parseIdentityProof(stdout);
+            if (request.identityProofPubkey && !identityProof) {
+                throw new Error("Identity proof was requested (publish nsec available) but the signing tool produced no PAKSTR_IDENTITY_PROOF line. " +
+                    "Check the Java tool output above for errors.");
+            }
+            // Assert the proof binds to the requested publisher pubkey and the
+            // derived signing cert — catch divergence early, not later in publish.
+            if (identityProof && request.identityProofPubkey) {
+                if (identityProof.pubkeyHex.toLowerCase() !== request.identityProofPubkey.toLowerCase()) {
+                    throw new Error(`Identity proof pubkeyHex (${identityProof.pubkeyHex}) does not match the requested publisher pubkey (${request.identityProofPubkey})`);
+                }
+                if (identityProof.certHash.toLowerCase() !== signerSha256) {
+                    throw new Error(`Identity proof certHash (${identityProof.certHash}) does not match the signer certificate (${signerSha256})`);
+                }
+            }
             // Copy the signed APK out of the output volume to the host.
             const hostSigned = path_1.default.join(os_1.default.tmpdir(), `pakstr-signed-${(0, crypto_2.randomUUID)()}.apk`);
             this.copyFromVolume(outVolume, "/out/signed.apk", hostSigned);
@@ -75,7 +96,7 @@ class DockerSignRunner {
             // fs.rename fails with EXDEV. COPYFILE_FICLONE is a harmless hint.
             fs_1.default.copyFileSync(hostSigned, finalPath, fs_1.default.constants.COPYFILE_FICLONE);
             fs_1.default.rmSync(hostSigned, { force: true });
-            result = { signedApkPath: finalPath, signerSha256 };
+            result = { signedApkPath: finalPath, signerSha256, identityProof: identityProof ?? undefined };
         }
         catch (error) {
             primaryError = error;
@@ -162,6 +183,19 @@ function parseSignerSha(stdout) {
     }
     return match[1].toLowerCase();
 }
+/** Parse the PAKSTR_IDENTITY_PROOF line from sign.sh stdout, if present. */
+function parseIdentityProof(stdout) {
+    const match = stdout.match(/PAKSTR_IDENTITY_PROOF certHash=([0-9a-fA-F]{64}),pubkeyHex=([0-9a-fA-F]{64}),signature=([A-Za-z0-9+/]+={0,2}),createdAt=(\d+),expiry=(\d+)/);
+    if (!match)
+        return null;
+    return {
+        certHash: match[1].toLowerCase(),
+        pubkeyHex: match[2].toLowerCase(),
+        signature: match[3],
+        createdAt: parseInt(match[4], 10),
+        expiry: parseInt(match[5], 10),
+    };
+}
 /** Re-encode the secret bytes as a bech32 nsec string for the container env. */
 function nsecToString(secret) {
     // Lazy import to avoid a circular type dependency at module load.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",