propr-cli 0.8.4 → 0.8.6

package/dist/tui/render.js

@@ -6,7 +6,7 @@
  * In all cases the containers run detached, so the stack outlives this process.
  */
 import { getHostConfig } from "../orchestrator/index.js";
-import { renderStatusTable } from "../orchestrator/format.js";
+import { renderStatusTable, renderTunnelEndpointSummary } from "../orchestrator/format.js";
 import { ensureVibePromptCacheDir } from "../commands/initStack.js";
 import { createInterface } from "node:readline/promises";
 async function confirmRestart() {
@@ -71,8 +71,23 @@ export async function runStart(configManager, options) {
     }
     const ui = configManager.getUiEnabled();
     const docs = cfg.docsEnabled;
+    // cfg.uiTunnelEnabled already reflects a persisted `propr tunnel on|off`
+    // toggle (forwarded as an override in getHostConfig), falling back to the
+    // env-derived default when the toggle has never been set.
+    const tunnel = cfg.uiTunnelEnabled;
     orch.ensureNetwork(cfg, (l) => console.log(l));
-    const status = orch.startStack(cfg, { ui, docs, onLog: (l) => console.log(l) });
+    const status = orch.startStack(cfg, { ui, docs, tunnel, onLog: (l) => console.log(l) });
+    // When the tunnel is on, surface the concrete routed endpoints (not the base
+    // URL as a health target) so the operator can see where the hosted UI reaches
+    // this stack.
+    if (tunnel) {
+        const summary = renderTunnelEndpointSummary(cfg.uiPublicApiUrl);
+        if (summary.length > 0) {
+            console.log("");
+            for (const line of summary)
+                console.log(line);
+        }
+    }
     const interactive = options.tui !== false && Boolean(process.stdout.isTTY);
     if (!interactive) {
         console.log("");

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, PROPR_UI_PROXY_LABEL_PREFIX, 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.6';
+// 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,113 @@ 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 a {@link PROPR_UI_PROXY_LABEL_PREFIX} host on
+ * {@link PROPR_UI_PROXY_SUFFIX} so the hosted UI can reach it.
+ */
+export const DEFAULT_PROPR_UI_ORIGIN = 'https://app.propr.dev';
+/**
+ * DNS suffix and label prefix for per-instance UI/API tunnel hostnames. Each
+ * local stack with an instance id is reachable at
+ * `https://t-<instanceId>.propr.dev`, so the hosted UI at
+ * {@link DEFAULT_PROPR_UI_ORIGIN} can discover and address it.
+ */
+export const PROPR_UI_PROXY_SUFFIX = 'propr.dev';
+export const PROPR_UI_PROXY_LABEL_PREFIX = 't-';
+/**
+ * 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 (`t-<id>.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 public tunnel host pattern. Returns `https://t-abc123.propr.dev`
+ * for instance id `abc123`. A caller may pass either the bare instance id or the
+ * public DNS label (`t-abc123`); the returned URL is canonicalized. 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 = normalizeProprInstanceId(instanceId);
+    if (!isValidProprInstanceId(id))
+        return undefined;
+    return `https://${PROPR_UI_PROXY_LABEL_PREFIX}${id.toLowerCase()}.${PROPR_UI_PROXY_SUFFIX}`;
+}
+/**
+ * Whether a URL is a hosted per-instance proxy URL (`https://t-<id>.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
+ * `t-<instance-id>` label in front of the shared {@link PROPR_UI_PROXY_SUFFIX}.
+ * Other propr.dev hosts like `app.propr.dev` and nested hosts are rejected. It
+ * must also be a bare origin: a non-root path, query, or fragment (e.g.
+ * `https://t-abc.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;
+        const label = hostname.slice(0, -suffix.length);
+        if (label.includes('.') || !label.startsWith(PROPR_UI_PROXY_LABEL_PREFIX)) {
+            return false;
+        }
+        return isValidProprInstanceId(label.slice(PROPR_UI_PROXY_LABEL_PREFIX.length));
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeProprInstanceId(instanceId) {
+    const id = (instanceId ?? '').trim();
+    return id.startsWith(PROPR_UI_PROXY_LABEL_PREFIX)
+        ? id.slice(PROPR_UI_PROXY_LABEL_PREFIX.length)
+        : id;
+}
+/**
+ * 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.6",
   "description": "CLI for interacting with the ProPR backend",
   "type": "module",
   "bin": {
@@ -27,5 +27,5 @@
     "code-review",
     "automation"
   ],
-  "license": "ISC"
+  "license": "Apache-2.0"
 }