propr-cli 0.8.3 → 0.8.5

package/dist/vendor/shared/proprServiceUrls.js

@@ -0,0 +1,124 @@
+/**
+ * Default URLs for the vendor-run propr-routing service.
+ *
+ * The routing relay and the GitHub token relay are not separate deployments —
+ * they are the same Cloudflare Worker (propr-routing), served from a single
+ * custom domain and exposing every endpoint under `/v1`:
+ *   - `wss://webhook.propr.dev/v1/connect`     (routing WebSocket intake)
+ *   - `https://webhook.propr.dev/v1/relay-tokens`, `/v1/installation-token` …
+ *
+ * These constants are the single source of truth for that host so the CLI
+ * (`propr relay enroll`), the daemon dialer, and the boot/`propr check`
+ * prerequisite validators all agree on the hosted default without anyone having
+ * to set PROPR_ROUTING_URL / PROPR_GH_RELAY_URL by hand.
+ */
+/**
+ * Default routing WebSocket origin (PROPR_ROUTING_URL). A bare origin without a
+ * path — the routing service owns the `/v1/...` paths it appends (connect +
+ * payload pull), so a path here would corrupt the derived URLs.
+ */
+export const DEFAULT_PROPR_ROUTING_URL = 'wss://webhook.propr.dev';
+/**
+ * Default GitHub token relay base URL (PROPR_GH_RELAY_URL). Includes the `/v1`
+ * version prefix because the relay client appends paths like `/relay-tokens`
+ * 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/dist/vendor/shared/statusKeys.js

@@ -0,0 +1,14 @@
+/**
+ * Redis keys carrying cross-process runtime status.
+ *
+ * Centralized here so the daemon (publisher), the API status route, the CLI, and
+ * their tests all reference one string instead of duplicating literals that could
+ * silently drift out of sync.
+ */
+/**
+ * Routing WebSocket intake runtime state, published by the daemon and read by the
+ * API status route / `propr check` to report routing connectivity, last delivery
+ * id, and last ACK for the default routing_websocket intake path.
+ */
+export const ROUTING_STATUS_REDIS_KEY = 'system:status:routing';
+//# sourceMappingURL=statusKeys.js.map

package/dist/vendor/shared/validateRoutingUrl.js

@@ -0,0 +1,46 @@
+// URL.hostname returns brackets for IPv6, e.g. '[::1]'.
+const LOCALHOST_HOSTS = ['localhost', '127.0.0.1', '[::1]'];
+/**
+ * Validate a PROPR_ROUTING_URL origin. This is the single source of truth for
+ * the routing-URL policy, shared by the boot/CLI prerequisite checks
+ * (intakeModePrerequisites) and the daemon service that actually dials it
+ * (RoutingWebSocketIntakeService), so the two can never disagree.
+ *
+ * Policy:
+ *   - must be a parseable URL
+ *   - must use a secure scheme: `wss://` or `https://`
+ *     (`ws://`/`http://` is allowed ONLY for localhost development)
+ *   - must be a bare ORIGIN — no path/query/fragment — because the service owns
+ *     the `/v1/...` paths it appends (connect + payload pull); a configured path
+ *     like `wss://routing/v1` would corrupt the derived URLs (`/v1/v1/connect`).
+ *
+ * Note the `wss://`/`ws://` (and `https://`/`http://`) schemes are all accepted
+ * because the service derives both the WebSocket connect URL and the HTTP
+ * payload-pull URL from this single value. The default `wss://webhook.propr.dev`
+ * is valid under this policy.
+ *
+ * Returns an error message string, or `null` when valid.
+ */
+export function validateRoutingUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return `Routing URL ("${url}") is not a valid URL. Set PROPR_ROUTING_URL to a wss:// origin, e.g. wss://webhook.propr.dev.`;
+    }
+    const scheme = parsed.protocol;
+    if (scheme !== 'ws:' && scheme !== 'wss:' && scheme !== 'http:' && scheme !== 'https:') {
+        return `Routing URL must use wss:// or https:// (ws://, http:// only for localhost); got "${scheme}//".`;
+    }
+    const isSecure = scheme === 'wss:' || scheme === 'https:';
+    const isLocalhost = LOCALHOST_HOSTS.includes(parsed.hostname);
+    if (!isSecure && !isLocalhost) {
+        return 'Routing URL must use wss:// or https:// (ws://, http:// is only allowed for localhost).';
+    }
+    if (parsed.pathname.replace(/\/+$/, '') !== '' || parsed.search || parsed.hash) {
+        return `Routing URL must be an origin without a path (e.g. wss://webhook.propr.dev), got "${url}".`;
+    }
+    return null;
+}
+//# sourceMappingURL=validateRoutingUrl.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "propr-cli",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "CLI for interacting with the ProPR backend",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
     "commander": "^13.1.0",
     "dotenv": "^16.5.0",
     "ink": "^7.0.5",
-    "react": "^19.2.7"
+    "react": "19.2.7"
   },
   "keywords": [
     "propr",
@@ -27,5 +27,5 @@
     "code-review",
     "automation"
   ],
-  "license": "ISC"
+  "license": "Apache-2.0"
 }