propr-cli 0.8.4 → 0.8.5

package/dist/vendor/shared/index.js

@@ -10,7 +10,7 @@ export { validateRelayUrl } from './validateRelayUrl.js';
 // Export the hosted propr-routing service default URLs (one source of truth for
 // the webhook.propr.dev host shared by the CLI, the daemon dialer, and the
 // boot/check prerequisite validators)
-export { DEFAULT_PROPR_ROUTING_URL, DEFAULT_PROPR_GH_RELAY_URL, } from './proprServiceUrls.js';
+export { DEFAULT_PROPR_ROUTING_URL, DEFAULT_PROPR_GH_RELAY_URL, DEFAULT_PROPR_UI_ORIGIN, PROPR_UI_PROXY_SUFFIX, DEFAULT_CLOUDFLARED_IMAGE, proprInstanceProxyUrl, isValidProprInstanceId, isProprProxyUrl, proprTunnelEndpoints, } from './proprServiceUrls.js';
 // Export routing URL validation (shared by intake prerequisites and the daemon
 // routing service so the boot/CLI checks and the dialer agree on one policy)
 export { validateRoutingUrl } from './validateRoutingUrl.js';
@@ -25,6 +25,7 @@ export { validateIntakeModePrerequisites, } from './intakeModePrerequisites.js';
 // Export shared Redis status keys (one source of truth for cross-process status
 // keys so the daemon publisher, API status route, and CLI cannot drift)
 export { ROUTING_STATUS_REDIS_KEY } from './statusKeys.js';
+export { PROPR_VERSION, PROPR_API_COMPATIBILITY, PROPR_UI_COMPATIBILITY, PROPR_UI_SUPPORTED_API_COMPATIBILITY, getProprCompatibilityMetadata, evaluateProprApiCompatibility, } from './proprCompatibility.js';
 export { shortHash, buildDynamicLlmLabel, MAX_GITHUB_LABEL_LENGTH } from './labelUtils.js';
 // Export the default review guidance (the overridable part of the /review prompt)
 export { DEFAULT_REVIEW_GUIDANCE } from './reviewPrompt.js';

package/dist/vendor/shared/proprCompatibility.js

@@ -0,0 +1,70 @@
+// Public ProPR version surfaced to the hosted UI via `/api/compatibility`. This
+// must track the release version. The shared package is bundled for the browser
+// (no fs/JSON-import of package.json available within rootDir), so it is kept as
+// a constant rather than read from package.json at runtime. A release bump that
+// updates packages/shared/package.json or docker/launcher/manifest.json but
+// forgets this constant is caught by the drift test in
+// test/orchestratorProprUrlsDrift.test.ts, which asserts all three agree.
+export const PROPR_VERSION = '0.8.5';
+// Bump this only when the API/UI contract changes in a way the hosted UI must
+// account for. Patch releases that do not change the browser-facing contract can
+// keep the same compatibility version.
+export const PROPR_API_COMPATIBILITY = '2026-06-27';
+export const PROPR_UI_COMPATIBILITY = PROPR_API_COMPATIBILITY;
+export const PROPR_UI_SUPPORTED_API_COMPATIBILITY = [PROPR_API_COMPATIBILITY];
+export function getProprCompatibilityMetadata() {
+    return {
+        version: PROPR_VERSION,
+        apiCompatibility: PROPR_API_COMPATIBILITY,
+        uiCompatibility: PROPR_UI_COMPATIBILITY,
+    };
+}
+export function evaluateProprApiCompatibility(input) {
+    const apiCompatibility = input.apiCompatibility?.trim() || null;
+    const apiVersion = input.version?.trim() || null;
+    if (!apiCompatibility) {
+        return {
+            compatible: false,
+            apiCompatibility,
+            apiVersion,
+            reason: 'missing',
+            message: 'This ProPR instance does not publish API compatibility metadata. Update the local ProPR stack before using the hosted UI.',
+        };
+    }
+    if (PROPR_UI_SUPPORTED_API_COMPATIBILITY.includes(apiCompatibility)) {
+        return { compatible: true, apiCompatibility, apiVersion };
+    }
+    // PROPR_UI_SUPPORTED_API_COMPATIBILITY currently holds a single value, so
+    // oldest === newest and only the too_old / too_new branches below can fire (the
+    // final `unsupported` branch is unreachable today). These are forward-looking:
+    // once the UI supports a range with gaps, an in-range-but-unsupported value can
+    // occur and the `unsupported` branch covers it.
+    const oldestSupported = PROPR_UI_SUPPORTED_API_COMPATIBILITY[0];
+    const newestSupported = PROPR_UI_SUPPORTED_API_COMPATIBILITY[PROPR_UI_SUPPORTED_API_COMPATIBILITY.length - 1];
+    if (apiCompatibility < oldestSupported) {
+        return {
+            compatible: false,
+            apiCompatibility,
+            apiVersion,
+            reason: 'too_old',
+            message: `This ProPR instance is too old for the hosted UI. Update the local ProPR stack to API compatibility ${oldestSupported} or newer.`,
+        };
+    }
+    if (apiCompatibility > newestSupported) {
+        return {
+            compatible: false,
+            apiCompatibility,
+            apiVersion,
+            reason: 'too_new',
+            message: `This ProPR instance is newer than the hosted UI supports. Update the hosted UI or use the matching local UI for API compatibility ${apiCompatibility}.`,
+        };
+    }
+    return {
+        compatible: false,
+        apiCompatibility,
+        apiVersion,
+        reason: 'unsupported',
+        message: `This hosted UI supports API compatibility ${PROPR_UI_SUPPORTED_API_COMPATIBILITY.join(', ')}, but the local ProPR instance reports ${apiCompatibility}.`,
+    };
+}
+//# sourceMappingURL=proprCompatibility.js.map

package/dist/vendor/shared/proprServiceUrls.js

@@ -24,4 +24,101 @@ export const DEFAULT_PROPR_ROUTING_URL = 'wss://webhook.propr.dev';
  * directly to this value.
  */
 export const DEFAULT_PROPR_GH_RELAY_URL = 'https://webhook.propr.dev/v1';
+/**
+ * Origin of the hosted Propr UI (https://app.propr.dev). This is where the
+ * managed control plane is served from; a local stack exposes its own UI on a
+ * tunnel under {@link PROPR_UI_PROXY_SUFFIX} so the hosted UI can reach it.
+ */
+export const DEFAULT_PROPR_UI_ORIGIN = 'https://app.propr.dev';
+/**
+ * DNS suffix for per-instance UI/API tunnel hostnames. Each local stack with an
+ * instance id is reachable at `https://<instanceId>.proxy.propr.dev`, so the
+ * hosted UI at {@link DEFAULT_PROPR_UI_ORIGIN} can discover and address it.
+ */
+export const PROPR_UI_PROXY_SUFFIX = 'proxy.propr.dev';
+/**
+ * Default Cloudflare Tunnel image used to expose the local stack's UI/API to
+ * the hosted control plane when a UI tunnel is enabled. This is only a fallback:
+ * the launcher prefers the `cloudflared` entry pinned in the stack manifest
+ * (docker/launcher/manifest.json). Keep this tag in sync with that manifest pin
+ * so the effective default is the same regardless of which source supplies it.
+ */
+export const DEFAULT_CLOUDFLARED_IMAGE = 'cloudflare/cloudflared:2024.12.2';
+/**
+ * Whether an instance id is usable as a single DNS label in the per-instance
+ * proxy hostname (`<id>.proxy.propr.dev`). Enforces the standard label rules:
+ * 1–63 characters, ASCII letters/digits/hyphens only, and no leading or
+ * trailing hyphen. This rejects spaces, slashes, dots, underscores, and other
+ * characters that would produce an invalid or ambiguous hostname.
+ */
+export function isValidProprInstanceId(instanceId) {
+    const id = (instanceId ?? '').trim();
+    return /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(id);
+}
+/**
+ * Derive the public API/UI URL for a local stack from its instance id, using
+ * the shared {@link PROPR_UI_PROXY_SUFFIX}. Returns `https://abc123.proxy.propr.dev`
+ * for instance id `abc123`. Returns `undefined` for a missing/blank id — or an
+ * id that is not a valid DNS label (see {@link isValidProprInstanceId}) — so
+ * callers can fall back to an explicit URL or a local-development default
+ * rather than emitting a malformed hostname. The id is lowercased so a
+ * mixed-case instance id yields a canonical hostname (DNS is case-insensitive).
+ */
+export function proprInstanceProxyUrl(instanceId) {
+    const id = (instanceId ?? '').trim();
+    if (!isValidProprInstanceId(id))
+        return undefined;
+    return `https://${id.toLowerCase()}.${PROPR_UI_PROXY_SUFFIX}`;
+}
+/**
+ * Whether a URL is a hosted per-instance proxy URL (`https://<id>.proxy.propr.dev`).
+ * propr-routing only forwards `/api/*` and `/socket.io/*` on these hosts, so the
+ * tunnel base URL must be one of them. Requires https and *exactly one* valid
+ * instance-id label in front of the shared {@link PROPR_UI_PROXY_SUFFIX} — a
+ * multi-label host like `foo.bar.proxy.propr.dev` is rejected because routing
+ * only addresses a single instance label. It must also be a bare origin: a
+ * non-root path, query, or fragment (e.g. `https://abc.proxy.propr.dev/api`) is
+ * rejected because {@link proprTunnelEndpoints} appends `/api/...` itself and a
+ * base path would double it up (`.../api/api/status`). Returns false for a
+ * malformed URL.
+ */
+export function isProprProxyUrl(url) {
+    if (!url)
+        return false;
+    try {
+        const { protocol, hostname, pathname, search, hash } = new URL(url);
+        if (protocol !== 'https:')
+            return false;
+        // Must be a bare origin — the tunnel endpoint helpers own the path suffix.
+        // Trailing slashes (`/`, `//`) are tolerated (callers trim them); any real
+        // path segment, query, or fragment is rejected so a base path can't double
+        // up the appended `/api/...`.
+        if (/[^/]/.test(pathname) || search || hash)
+            return false;
+        const suffix = `.${PROPR_UI_PROXY_SUFFIX}`;
+        if (!hostname.endsWith(suffix))
+            return false;
+        // The portion before the suffix must be a single valid DNS label (no dots),
+        // so isValidProprInstanceId rejects nested hosts like `a.b.proxy.propr.dev`.
+        return isValidProprInstanceId(hostname.slice(0, -suffix.length));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The concrete endpoints the hosted UI reaches through the tunnel base URL.
+ * propr-routing only allows `/api/*` and `/socket.io/*`, so the base (root) URL
+ * itself intentionally returns 404 — it is NOT a health target. Use `apiStatus`
+ * to probe liveness. The base is normalized (trailing slashes trimmed) so the
+ * derived paths never double up a slash.
+ */
+export function proprTunnelEndpoints(baseUrl) {
+    const base = baseUrl.replace(/\/+$/, '');
+    return {
+        apiStatus: `${base}/api/status`,
+        socketIo: `${base}/socket.io/`,
+        root: `${base}/`,
+    };
+}
 //# sourceMappingURL=proprServiceUrls.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "propr-cli",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "CLI for interacting with the ProPR backend",
   "type": "module",
   "bin": {
@@ -27,5 +27,5 @@
     "code-review",
     "automation"
   ],
-  "license": "ISC"
+  "license": "Apache-2.0"
 }