pakstr 0.12.1 → 0.13.0

package/dist/commands/init.js

@@ -167,6 +167,7 @@ function renderConfig(c) {
 app:
   appId: ${c.appId}        # REQUIRED. Java package id; also feeds key derivation.
   appName: ${escapeYamlScalar(c.appName)}                  # REQUIRED. Launcher label.
+  # Using auto requires a stable SemVer Git tag pointing exactly at HEAD.
   versionName: "${c.versionName}"           # REQUIRED. Human-readable version.
   versionCode: ${c.versionCode}                 # REQUIRED. Monotonic integer.
   description: ${c.description === "" ? '""' : escapeYamlScalar(c.description)}                # OPTIONAL.

package/dist/core/pakstrConfig.js

@@ -10,6 +10,7 @@ exports.validatePakstrConfig = validatePakstrConfig;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
+const versioning_1 = require("./versioning");
 /**
  * Pakstr configuration model — the single `pakstr.yaml` file.
  * Spec: docs/SPEC.md §3. Secrets are NEVER placed in this file.
@@ -77,11 +78,16 @@ function loadPakstrConfig(configPath) {
     }
     return resolveAndValidate(raw, resolvedPath);
 }
+/**
+ * Validate an in-memory Pakstr configuration through `resolveAndValidate`.
+ * Automatic version fields may invoke Git tag resolution and fail with Git or
+ * version-resolution errors.
+ */
 function validatePakstrConfig(config, configPath) {
     resolveAndValidate(config, configPath ?? "");
 }
 function resolveAndValidate(config, configPath) {
-    const configDir = path_1.default.dirname(configPath);
+    const configDir = configPath ? path_1.default.dirname(configPath) : process.cwd();
     const where = (field) => configPath ? `${field} (in ${configPath})` : field;
     const app = config.app;
     if (!app || typeof app !== "object")
@@ -90,7 +96,16 @@ function resolveAndValidate(config, configPath) {
     requireString(app.appId, "app.appId", configPath);
     requireString(app.appName, "app.appName", configPath);
     requireString(app.versionName, "app.versionName", configPath);
-    requirePositiveInt(app.versionCode, "app.versionCode", configPath);
+    if (app.versionCode !== versioning_1.AUTO_VERSION) {
+        requirePositiveInt(app.versionCode, "app.versionCode", configPath);
+    }
+    let resolvedVersion;
+    try {
+        resolvedVersion = (0, versioning_1.resolveReleaseVersion)(app.versionName, app.versionCode, configDir);
+    }
+    catch (error) {
+        fail(`Unable to resolve app version: ${error instanceof Error ? error.message : String(error)}`, configPath);
+    }
     // appId rules (§3.3): non-empty, ≤255 UTF-8 bytes, equals trimmed form,
     // and must be a valid Android/Java package name (segments of lower-case
     // alphanumerics + underscores separated by dots; no hyphens). AAPT rejects
@@ -109,7 +124,7 @@ function resolveAndValidate(config, configPath) {
     if (/[\r\n]/.test(app.appName)) {
         fail(`${where("app.appName")} must not contain line breaks`, configPath);
     }
-    if (/[\r\n"\\]/.test(app.versionName)) {
+    if (/[\r\n"\\]/.test(resolvedVersion.versionName)) {
         fail(`${where("app.versionName")} must not contain line breaks, quotes, or backslashes`, configPath);
     }
     if (app.description !== undefined && typeof app.description !== "string") {
@@ -155,6 +170,11 @@ function resolveAndValidate(config, configPath) {
     const builder = build.builder ?? "docker";
     const outDefault = path_1.default.join(configDir, "build", `${app.appId}.apk`);
     const out = build.out ? path_1.default.resolve(configDir, build.out) : outDefault;
+    const resolvedApp = {
+        ...app,
+        versionName: resolvedVersion.versionName,
+        versionCode: resolvedVersion.versionCode,
+    };
     // publish section
     const publish = config.publish;
     let zapstoreEnabled = true;
@@ -184,7 +204,7 @@ function resolveAndValidate(config, configPath) {
     return {
         configDir,
         configPath,
-        app,
+        app: resolvedApp,
         build: { web: webAbs, out, builder },
         publish: { zapstoreEnabled, publishKey, relay, blossom },
     };

package/dist/core/versioning.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_MAJOR = exports.MAX_MINOR_OR_PATCH = exports.MAX_ANDROID_VERSION_CODE = exports.AUTO_VERSION = void 0;
+exports.parseStableSemVer = parseStableSemVer;
+exports.encodeAndroidVersionCode = encodeAndroidVersionCode;
+exports.resolveExactGitReleaseVersion = resolveExactGitReleaseVersion;
+exports.resolveReleaseVersion = resolveReleaseVersion;
+const child_process_1 = require("child_process");
+exports.AUTO_VERSION = "auto";
+exports.MAX_ANDROID_VERSION_CODE = 2_100_000_000;
+exports.MAX_MINOR_OR_PATCH = 99;
+exports.MAX_MAJOR = 209_999;
+const STABLE_SEMVER_RE = /^(?:v)?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+function parseStableSemVer(value) {
+    const match = STABLE_SEMVER_RE.exec(value);
+    if (!match) {
+        throw new Error(`Unsupported release version "${value}"; expected stable SemVer such as v1.2.3 or 1.2.3`);
+    }
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    if (![major, minor, patch].every(Number.isSafeInteger)) {
+        throw new Error(`Release version "${value}" contains an unsafe integer`);
+    }
+    return { major, minor, patch, versionName: `${major}.${minor}.${patch}` };
+}
+function encodeAndroidVersionCode(version) {
+    if (version.minor > exports.MAX_MINOR_OR_PATCH || version.patch > exports.MAX_MINOR_OR_PATCH) {
+        throw new Error(`Release version "${version.versionName}" cannot be encoded automatically: minor and patch must each be between 0 and ${exports.MAX_MINOR_OR_PATCH}`);
+    }
+    if (version.major > exports.MAX_MAJOR) {
+        throw new Error(`Release version "${version.versionName}" cannot be encoded automatically: major must be between 0 and ${exports.MAX_MAJOR}`);
+    }
+    const versionCode = ((version.major * 100) + version.minor) * 100 + version.patch + 1;
+    if (!Number.isSafeInteger(versionCode) || versionCode <= 0 || versionCode > exports.MAX_ANDROID_VERSION_CODE) {
+        throw new Error(`Release version "${version.versionName}" produces Android versionCode ${versionCode}; expected 1..${exports.MAX_ANDROID_VERSION_CODE}`);
+    }
+    return versionCode;
+}
+function resolveExactGitReleaseVersion(cwd) {
+    let output;
+    try {
+        output = (0, child_process_1.execFileSync)("git", ["tag", "--points-at", "HEAD"], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 5_000,
+            maxBuffer: 4 * 1024 * 1024,
+            killSignal: "SIGKILL",
+        });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to resolve an automatic release version from Git in ${cwd}: ${detail}`);
+    }
+    const tags = output.split(/\r?\n/).filter(Boolean);
+    const releases = new Map();
+    for (const tag of tags) {
+        try {
+            const release = parseStableSemVer(tag);
+            releases.set(release.versionName, release);
+        }
+        catch {
+            // Non-release tags on HEAD do not become release versions.
+        }
+    }
+    if (releases.size === 0) {
+        const observed = tags.length ? ` Tags on HEAD: ${tags.join(", ")}.` : "";
+        throw new Error(`HEAD has no exact stable SemVer release tag. Create a tag such as v1.2.3 or set app.versionName explicitly.${observed}`);
+    }
+    if (releases.size > 1) {
+        throw new Error(`HEAD has conflicting stable SemVer release tags: ${[...releases.keys()].sort((a, b) => a.localeCompare(b, undefined, { numeric: true })).join(", ")}`);
+    }
+    return [...releases.values()][0];
+}
+function resolveReleaseVersion(versionName, versionCode, cwd) {
+    let release;
+    let resolvedName = versionName;
+    if (versionName === exports.AUTO_VERSION) {
+        release = resolveExactGitReleaseVersion(cwd);
+        resolvedName = release.versionName;
+    }
+    if (versionCode === exports.AUTO_VERSION) {
+        release ??= parseStableSemVer(resolvedName);
+        return {
+            versionName: resolvedName,
+            versionCode: encodeAndroidVersionCode(release),
+        };
+    }
+    return { versionName: resolvedName, versionCode };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -27,7 +27,8 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && node --test test/*.test.js",
+    "type-test": "tsc -p tsconfig.type-tests.json",
+    "test": "npm run build && npm run type-test && node --test test/*.test.js",
     "start": "node dist/index.js",
     "dev": "ts-node src/index.ts",
     "pack:test": "npm pack"