@rightkit/document-workspace 0.0.0-stage → 0.1.0

package/dist/state/updateLicense.js

@@ -0,0 +1,340 @@
+import { browserQaLicenseClient, nativeIpc, openExternal } from "@rightkit/document-core/state/tauriBridge";
+import { createLicenseClient } from "@rightkit/license";
+import { createPersistedCheckCache, isNewerVersion as semverIsNewer, } from "@rightkit/app-update";
+import { publicInstallerUrl as suitePublicInstallerUrl } from "@rightkit/app-update/suite-api";
+import { UPDATE_MESSAGES, createNativeUpdateClient, } from "@rightkit/app-update/native";
+import { isMac } from "@rightkit/document-core/platform";
+import { logError } from "@rightkit/document-core/state/diagnostics";
+import { hostAppName } from "../appName.js";
+const FALLBACK_APP_VERSION = "0.0.0-dev";
+export function resolvedAppVersion() {
+    const version = typeof __APP_VERSION__ === "string" ? __APP_VERSION__.trim() : "";
+    if (version)
+        return version;
+    const message = `${hostAppName()} build is missing __APP_VERSION__; release/update version truth is unavailable.`;
+    if (import.meta.env?.PROD) {
+        throw new Error(message);
+    }
+    console.warn(`${message} Using ${FALLBACK_APP_VERSION} for this non-production harness.`);
+    return FALLBACK_APP_VERSION;
+}
+export const APP_VERSION = resolvedAppVersion();
+// Purchase CTA. /pricing is the real route (→ /checkout); /updates does not exist (was a 404).
+export const UPDATE_LICENSE_URL = "https://viewright.cc/pricing/";
+// The Right Suite app key: the owners (the native update host and @rightkit/app-update/suite-api)
+// derive every host and URL from it, so this file names none.
+const APP_KEY = "viewright";
+// One-time purge of records the pre-cutover webview kept: the token-bearing licence and the
+// device-id cache. Native code owns both now; nothing token-bearing may remain in web storage.
+for (const legacyKey of ["vr.updateLicense.v1", "vr.deviceId.v1"]) {
+    try {
+        localStorage.removeItem(legacyKey);
+    }
+    catch {
+        /* ignore */
+    }
+}
+// ── Licence: the shell-owned native client. The webview holds no key, token, device id or
+//    record; it sends commands and receives validated LicenseView display values. ──
+let licenseClientPromise = null;
+export function getLicenseClient() {
+    licenseClientPromise ??= (async () => (await browserQaLicenseClient()) ?? createLicenseClient(nativeIpc))();
+    return licenseClientPromise;
+}
+// ── Updates: the shell-owned native update host. Check yields an opaque handle; download and
+//    install take that handle. authorization headers, tokens and licence binding stay native. ──
+let nativeUpdates = null;
+function updates() {
+    nativeUpdates ??= createNativeUpdateClient(nativeIpc);
+    return nativeUpdates;
+}
+/** Refusals that mean "this licence does not entitle the update" (nudge to the licence panel). */
+const LICENSE_REFUSALS = new Set([
+    "notLicensed",
+    "expired",
+    "revoked",
+    "tierIneligible",
+    "disabledNoPublicPatch",
+]);
+let pendingUpdate = null;
+let pendingExternalUpdateUrl = null;
+function publicInstallerUrl() {
+    return suitePublicInstallerUrl(APP_KEY, isMac() ? "mac/current/Host_universal.dmg" : "windows/current/Host_x64-setup.exe");
+}
+export async function openPendingExternalUpdate() {
+    if (pendingExternalUpdateUrl)
+        await openExternal(pendingExternalUpdateUrl);
+}
+// ── Release status (app policy: manual-download fallback and the paid-update nudge). The shell's
+//    update host reads it natively (`rightkit_update_release_status`, https only, no redirect, closed
+//    shape); the webview holds no network capability. The platform filter is set natively. ──
+function fetchCurrentReleaseStatus() {
+    return updates().releaseStatus();
+}
+async function latestProUpdateVersion() {
+    try {
+        const status = await fetchCurrentReleaseStatus();
+        return status.updateVersion && isNewerVersion(status.updateVersion, APP_VERSION)
+            ? status.updateVersion
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Last-known-good update-check cache (@rightkit/app-update createPersistedCheckCache). A
+//    network hiccup after an earlier good check shows that result instead of "failed". Only
+//    results that need no process-local handle are persisted. ──
+export const UPDATE_CHECK_CACHE_KEY = "vr.updateCheck.v3";
+// A persisted result younger than this is served without a network round-trip.
+const UPDATE_CHECK_DEBOUNCE_MS = 30_000;
+const checkCacheStore = {
+    async read() {
+        try {
+            return localStorage.getItem(UPDATE_CHECK_CACHE_KEY);
+        }
+        catch {
+            return null;
+        }
+    },
+    async write(text) {
+        localStorage.setItem(UPDATE_CHECK_CACHE_KEY, text);
+    },
+};
+const updateCheckCache = createPersistedCheckCache({
+    store: checkCacheStore,
+    minIntervalMs: UPDATE_CHECK_DEBOUNCE_MS,
+    // Also the write gate: a result that fails validation is returned but never persisted.
+    validate: (value) => {
+        const v = value;
+        return (typeof v === "object" &&
+            v !== null &&
+            (v.state === "current" || v.state === "available-external") &&
+            typeof v.version === "string");
+    },
+});
+function applyCached(cached, setLatestVersion, setUpdateState, setLatestTier) {
+    setLatestVersion(cached.version);
+    setLatestTier?.(cached.tier ?? null);
+    if (cached.state === "available-external")
+        pendingExternalUpdateUrl = publicInstallerUrl();
+    setUpdateState(cached.state);
+}
+async function resultFromCheck(view) {
+    if (!view.available) {
+        const nudge = await latestProUpdateVersion();
+        return nudge
+            ? { state: "license-required", tier: "update", version: nudge }
+            : { state: "current", tier: null, version: APP_VERSION };
+    }
+    const tier = view.kind ?? null;
+    const version = view.version ?? "";
+    if (view.eligible && view.handleId) {
+        return { state: "available", tier, version, handleId: view.handleId };
+    }
+    if (view.refusal === "offline")
+        throw new Error("offline");
+    if (LICENSE_REFUSALS.has(view.refusal))
+        return { state: "license-required", tier, version };
+    return { state: "failed" };
+}
+// Step 1: check only, through the native update host.
+export async function checkForUpdate(setLatestVersion, setUpdateState, setLatestTier) {
+    pendingUpdate = null;
+    pendingExternalUpdateUrl = null;
+    setUpdateState("checking");
+    let outcome;
+    try {
+        outcome = await updateCheckCache.run(async () => resultFromCheck(await updates().check()));
+    }
+    catch {
+        return checkPublicReleaseFallback(setLatestVersion, setUpdateState, setLatestTier);
+    }
+    const result = outcome.value;
+    if (outcome.source === "last-known-good") {
+        if (result.state === "current") {
+            applyCached(result, setLatestVersion, setUpdateState, setLatestTier);
+            return "current";
+        }
+        return checkPublicReleaseFallback(setLatestVersion, setUpdateState, setLatestTier);
+    }
+    if (outcome.source === "cache" && (result.state === "current" || result.state === "available-external")) {
+        applyCached(result, setLatestVersion, setUpdateState, setLatestTier);
+        return result.state;
+    }
+    if (result.state === "available") {
+        setLatestVersion(result.version);
+        setLatestTier?.(result.tier);
+        pendingUpdate = { handleId: result.handleId, tier: result.tier };
+        setUpdateState("available");
+        return "available";
+    }
+    if (result.state === "license-required") {
+        setLatestVersion(result.version);
+        setLatestTier?.(result.tier);
+        setUpdateState("license-required");
+        return "license-required";
+    }
+    if (result.state === "current") {
+        setLatestTier?.(null);
+        setUpdateState("current");
+        return "current";
+    }
+    setUpdateState("failed");
+    return "failed";
+}
+async function checkPublicReleaseFallback(setLatestVersion, setUpdateState, setLatestTier) {
+    try {
+        const status = await fetchCurrentReleaseStatus();
+        const version = status.patchVersion?.trim() ?? "";
+        if (!version || !isNewerVersion(version, APP_VERSION)) {
+            if (status.updateVersion && isNewerVersion(status.updateVersion, APP_VERSION)) {
+                setLatestVersion(status.updateVersion);
+                setLatestTier?.("update");
+                setUpdateState("license-required");
+                return "license-required";
+            }
+            setUpdateState("current");
+            return "current";
+        }
+        pendingExternalUpdateUrl = publicInstallerUrl();
+        setLatestVersion(version);
+        setLatestTier?.(null);
+        setUpdateState("available-external");
+        await updateCheckCache.run(async () => ({ state: "available-external", tier: null, version }), { force: true });
+        return "available-external";
+    }
+    catch {
+        setUpdateState("failed");
+        return "failed";
+    }
+}
+async function relaunchAfterInstall() {
+    try {
+        const { relaunch } = await import("@tauri-apps/plugin-process");
+        await relaunch();
+    }
+    catch {
+        /* the host may already be restarting; the install itself succeeded */
+    }
+}
+// Step 2: explicit download + install of the update found by checkForUpdate(), then relaunch.
+export async function installPendingUpdate(setUpdateState, setInstallError) {
+    if (!pendingUpdate)
+        return "idle";
+    const { handleId, tier } = pendingUpdate;
+    pendingUpdate = null;
+    setUpdateState("installing");
+    let failure = UPDATE_MESSAGES.updateFailed;
+    try {
+        const downloaded = await updates().download(handleId);
+        if (downloaded.state === "downloaded") {
+            const installed = await updates().install(handleId);
+            if (installed.state === "installing") {
+                await relaunchAfterInstall();
+                return "installing";
+            }
+            if (installed.state === "refused" && installed.reason && LICENSE_REFUSALS.has(installed.reason)) {
+                setUpdateState("license-required");
+                return "license-required";
+            }
+            failure = UPDATE_MESSAGES[installed.message] || failure;
+        }
+        else {
+            if (downloaded.state === "refused" && downloaded.reason && LICENSE_REFUSALS.has(downloaded.reason)) {
+                setUpdateState("license-required");
+                return "license-required";
+            }
+            failure = UPDATE_MESSAGES[downloaded.message] || failure;
+        }
+    }
+    catch (error) {
+        // NativeUpdateClientError text is a fixed, closed message; native detail never crosses IPC.
+        if (error instanceof Error && error.message)
+            failure = error.message;
+    }
+    // Surface the failure two ways: setInstallError feeds the UI (ephemeral) and logError lands it as
+    // renderer_error in the diagnostics export (durable). On a patch, also stage the public installer
+    // URL so the user can recover via a manual download.
+    if (tier === "patch")
+        pendingExternalUpdateUrl = publicInstallerUrl();
+    setInstallError?.(failure);
+    logError("update:install-failed");
+    setUpdateState("install-failed");
+    return "install-failed";
+}
+/** True while a manual-download installer URL is staged (public fallback or failed patch install). */
+export function hasPendingExternalUpdate() {
+    return pendingExternalUpdateUrl !== null;
+}
+/**
+ * the host app update flow as the function-style client `@rightkit/settings-ui` `updatesSection`
+ * expects (`UpdatesAdapter`): check()/install() resolve to an `AutoUpdateStatus`. The explicit
+ * check -> install split, the last-known-good cache and the public-release fallback stay in
+ * checkForUpdate()/installPendingUpdate(); this only maps their UpdateState into the shared status.
+ * `onChange` fires after each call so UI outside the section can re-read hasPendingExternalUpdate().
+ */
+export function createHostUpdatesAdapter(onChange) {
+    let version = "";
+    let tier = null;
+    const toStatus = (state, error = "") => {
+        switch (state) {
+            case "current":
+                return { kind: "up_to_date" };
+            case "available":
+                return { kind: "available", version, tier, eligible: true };
+            case "license-required":
+                return { kind: "available", version, tier, eligible: false, reason: "pro_required" };
+            case "available-external":
+                return { kind: "deferred", version, tier: null, reason: "manual_download" };
+            case "installing":
+                return { kind: "ready", version, tier };
+            case "install-failed":
+                return { kind: "error", message: error || "The updater could not finish installing this release." };
+            case "failed":
+                return { kind: "error", message: "Couldn't check releases." };
+            default:
+                return { kind: "idle" };
+        }
+    };
+    return {
+        async check() {
+            try {
+                const state = await checkForUpdate((v) => (version = v), () => { }, (t) => (tier = t));
+                return toStatus(state);
+            }
+            finally {
+                onChange?.();
+            }
+        },
+        async install() {
+            let error = "";
+            try {
+                const state = await installPendingUpdate(() => { }, (m) => (error = m));
+                return state === "idle"
+                    ? { kind: "error", message: "No update is ready to install. Check for updates first." }
+                    : toStatus(state, error);
+            }
+            finally {
+                onChange?.();
+            }
+        },
+    };
+}
+/** Startup check through the native host. The host reads the licence record, so a paid update is
+ *  announced for a licensed user; a failure is advisory and returns null. */
+export async function checkForBackgroundUpdate() {
+    const view = await updates().check();
+    return view.available && view.eligible && view.version
+        ? { version: view.version, tier: view.kind ?? null }
+        : null;
+}
+/** Package semver compare, but an unparseable version never counts as newer (it throws on garbage). */
+function isNewerVersion(candidate, current) {
+    try {
+        return semverIsNewer(candidate, current);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/styles/explorer.css

@@ -0,0 +1,219 @@
+/* Explorer sidebar (src/app/sidebar/explorer/) — collapsible sections, lazy tree rows, ellipsis
+   context menus. Rendered inside the sidebar's .vr-chrome scope, so the shared tokens already map
+   to the CHROME palette (index.css .vr-chrome: --ink = --chrome-hover, --panel-2 = --chrome-2,
+   --muted = --chrome-muted, --line = --chrome-line, --paper = --chrome-paper; --copper = accent).
+   Visual reference: docs/design/viewright-tabs-explorer.html (.sec/.sec-h/.tree/.row). */
+
+.vr-explorer {
+  padding: 2px 6px 12px 4px;
+  white-space: nowrap;
+  font-size: var(--vr-text-sm);
+  line-height: 1.35;
+}
+
+/* ── Section header (mockup .sec-h: 10.5px, uppercase, tracked) ───────────── */
+.vr-x-sec {
+  margin-top: 10px;
+}
+.vr-x-sec-h {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  width: 100%;
+  padding: 4px 6px;
+  border: 0;
+  border-radius: 6px;
+  background: none;
+  font-size: var(--vr-text-xs);
+  font-weight: 600;
+  letter-spacing: 0.09em;
+  text-transform: uppercase;
+  color: var(--muted);
+  text-align: left;
+  cursor: default;
+}
+.vr-x-sec-h:hover {
+  color: var(--paper);
+}
+.vr-x-sec-h:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 2px var(--copper);
+}
+.vr-x-sec-caret {
+  flex: none;
+  color: var(--muted);
+  transition: transform 0.15s ease;
+}
+.vr-x-sec.closed .vr-x-sec-caret {
+  transform: rotate(-90deg);
+}
+.vr-x-sec-count {
+  flex: none;
+  margin-left: auto;
+  padding: 0 6px;
+  border-radius: 999px;
+  background: var(--panel-2);
+  color: var(--muted);
+  font-size: var(--vr-text-xs);
+  font-weight: 600;
+  letter-spacing: 0;
+}
+.vr-x-sec.closed .vr-x-sec-b {
+  display: none;
+}
+
+/* ── Rows (mockup .row): one height for tree rows and leaf rows alike ─────── */
+.vr-x-row {
+  position: relative;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  height: 26px;
+  padding: 0 6px;
+  border: 0;
+  border-radius: 7px;
+  background: none;
+  font-size: var(--vr-text-sm);
+  color: var(--paper);
+  text-align: left;
+  cursor: default;
+}
+.vr-x-row:hover {
+  background: color-mix(in srgb, var(--ink) 55%, transparent);
+}
+/* Current file: quiet chromeHover fill + semibold, held even without tree focus (mockup .row.sel). */
+.vr-x-row[aria-selected="true"],
+.vr-x-row.vr-x-sel,
+.vr-x-row[aria-current="true"] {
+  background: var(--ink);
+  font-weight: 600;
+}
+.vr-x-row:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 2px var(--copper);
+}
+/* Unsupported files: real path but no broker grant — dimmed, inert. */
+.vr-x-row.vr-x-dim {
+  opacity: 0.5;
+}
+/* .vr-x-lrow kept as the leaf-row marker; heights are uniform now. */
+
+.vr-x-caret {
+  width: 12px;
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--muted);
+}
+.vr-x-icn {
+  flex: none;
+  width: 16px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--muted);
+}
+.vr-x-name {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+/* "In a tab" indicator for files that are already open (not the active one). */
+.vr-x-open {
+  flex: none;
+  width: 6px;
+  height: 6px;
+  box-sizing: border-box;
+  border-radius: 50%;
+  border: 1.5px solid var(--muted);
+  background: transparent;
+}
+/* Hover "…" action (mockup .row .dots): overlays the row end on hover/focus only. */
+.vr-x-dots {
+  position: absolute;
+  right: 4px;
+  top: 50%;
+  transform: translateY(-50%);
+  display: none;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 18px;
+  padding: 0;
+  border: 0;
+  border-radius: 5px;
+  background: var(--panel-2);
+  color: var(--muted);
+}
+.vr-x-row:hover .vr-x-dots,
+.vr-x-row:focus-within .vr-x-dots {
+  display: inline-flex;
+}
+.vr-x-dots:hover {
+  color: var(--paper);
+}
+.vr-x-dots:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 2px var(--copper);
+}
+
+/* ── Quiet lines (empty sections/folders, notes, truncation, "show more") ─── */
+.vr-x-empty {
+  padding: 3px 8px 3px 24px;
+  font-size: var(--vr-text-sm);
+  color: var(--muted);
+}
+/* Permission/inline errors get real message text and may wrap. */
+.vr-x-note {
+  padding: 4px 8px 4px 24px;
+  font-size: var(--vr-text-sm);
+  line-height: 1.45;
+  color: var(--muted);
+  white-space: normal;
+}
+.vr-x-more {
+  display: block;
+  width: 100%;
+  padding: 3px 8px 3px 24px;
+  border: 0;
+  background: none;
+  font-size: var(--vr-text-sm);
+  color: var(--muted);
+  text-align: left;
+  cursor: default;
+}
+.vr-x-more:hover {
+  color: var(--paper);
+}
+.vr-x-more:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 2px var(--copper);
+}
+
+/* ── Slim action row under the sidebar titlebar (mockup .s-actions) ────────── */
+.vr-x-actions {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 0 10px 4px;
+}
+.vr-x-new {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  height: 24px;
+  padding: 0 10px;
+  border: 0.5px solid var(--line);
+  border-radius: 999px;
+  background: var(--panel-2);
+  color: var(--paper);
+  font-size: var(--vr-text-sm);
+  font-weight: 600;
+  cursor: default;
+}
+.vr-x-new:hover {
+  border-color: var(--muted);
+}