@omniviewdev/vite-plugin 0.4.2 → 0.5.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import path from "node:path";
+import path3 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/sharedPackages.ts
@@ -55,16 +55,346 @@ function safeFilename(packageName) {
   return result;
 }
 
+// src/workspace.ts
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+function workspaceViteRoots(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const roots = JSON.parse(raw);
+  if (!Array.isArray(roots) || roots.length === 0) {
+    throw new Error("OMNIVIEW_VITE_ALLOWED_ROOTS must be a nonempty JSON array");
+  }
+  return [...new Set(roots.map((root) => {
+    if (typeof root !== "string" || !path.isAbsolute(root) || root.includes("*") || root.includes("\0") || path.parse(root).root === root) {
+      throw new Error("Vite workspace roots must be explicit absolute repository directories");
+    }
+    const canonical = realpathSync(root);
+    if (canonical !== path.resolve(root) || !statSync(canonical).isDirectory()) {
+      throw new Error("Vite workspace roots must be canonical repository directories");
+    }
+    return canonical;
+  }))];
+}
+function workspaceVitePort(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!/^[0-9]+$/.test(raw)) {
+    throw new Error("Owned Vite port must be an integer");
+  }
+  const port = Number(raw);
+  if (port < 1 || port > 65535) {
+    throw new Error("Owned Vite port is outside 1..65535");
+  }
+  return port;
+}
+function workspaceViteCacheDirectory(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!path.isAbsolute(raw) || raw.includes("\0") || path.parse(raw).root === raw) {
+    throw new Error("Managed Vite cache must be an explicit absolute directory");
+  }
+  const canonical = realpathSync(raw);
+  if (canonical !== path.resolve(raw) || !statSync(canonical).isDirectory()) {
+    throw new Error("Managed Vite cache must be an existing canonical owned directory");
+  }
+  return canonical;
+}
+
+// src/feedback.ts
+import { execFileSync } from "node:child_process";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readSync,
+  realpathSync as realpathSync2,
+  statSync as statSync2,
+  watch
+} from "node:fs";
+import path2 from "node:path";
+var navigationTypes = { update: true, "full-reload": true, prune: true };
+var maximumStateBytes = 64 * 1024;
+var maximumStateSize = BigInt(maximumStateBytes);
+function feedbackContext(raw) {
+  const value = JSON.parse(raw);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("OMNIVIEW_VITE_FEEDBACK must be an explicit managed feedback context");
+  }
+  const context = value;
+  if (context.schemaVersion !== 1 || typeof context.workspaceID !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(context.workspaceID) || typeof context.generation !== "string" || !context.generation || context.generation.includes("\0") || typeof context.workspaceRoot !== "string" || !path2.isAbsolute(context.workspaceRoot) || context.workspaceRoot.includes("\0") || path2.parse(context.workspaceRoot).root === context.workspaceRoot || typeof context.file !== "string" || !path2.isAbsolute(context.file) || context.file.includes("\0") || path2.resolve(context.file) !== context.file) {
+    throw new Error("Managed Vite feedback requires versioned, explicit workspace and file ownership");
+  }
+  if (realpathSync2(context.workspaceRoot) !== context.workspaceRoot || !statSync2(context.workspaceRoot).isDirectory()) {
+    throw new Error("Managed Vite feedback workspace must be an existing canonical directory");
+  }
+  let authority;
+  if (context.authority !== void 0) {
+    if (!context.authority || typeof context.authority !== "object" || Array.isArray(context.authority)) {
+      throw new Error("Managed Vite feedback authority must be explicit supervisor ownership");
+    }
+    const value2 = context.authority;
+    if (typeof value2.executable !== "string" || !path2.isAbsolute(value2.executable) || value2.executable.includes("\0") || path2.resolve(value2.executable) !== value2.executable || realpathSync2(value2.executable) !== value2.executable || !lstatSync(value2.executable).isFile() || !value2.identity || typeof value2.identity !== "object" || Array.isArray(value2.identity)) {
+      throw new Error("Managed Vite feedback authority requires its exact canonical supervisor executable");
+    }
+    const identity = value2.identity;
+    if (typeof identity.volume !== "string" || !/^[0-9]+$/.test(identity.volume) || typeof identity.fileID !== "string" || !/^[0-9a-f]{32}$/.test(identity.fileID)) {
+      throw new Error("Managed Vite feedback authority requires the full stable file identity");
+    }
+    authority = {
+      executable: value2.executable,
+      identity: { volume: identity.volume, fileID: identity.fileID }
+    };
+  }
+  return {
+    schemaVersion: 1,
+    workspaceID: context.workspaceID,
+    generation: context.generation,
+    workspaceRoot: context.workspaceRoot,
+    file: context.file,
+    authority
+  };
+}
+function readViteFeedbackAuthority(raw) {
+  try {
+    const context = feedbackContext(raw);
+    if (!context.authority) {
+      return true;
+    }
+    const output = execFileSync(context.authority.executable, ["vite-feedback-read", "--context", raw], {
+      encoding: "utf8",
+      shell: false,
+      windowsHide: true,
+      timeout: 2e3,
+      maxBuffer: 1024,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const result = JSON.parse(output);
+    if (!result || typeof result !== "object" || Array.isArray(result) || Object.keys(result).length !== 1) {
+      return true;
+    }
+    return result.held !== false;
+  } catch {
+    return true;
+  }
+}
+function privateFeedbackFile(stat) {
+  const owner = process.getuid?.();
+  return stat.isFile() && owner !== void 0 && stat.uid === BigInt(owner) && (stat.mode & 0o777n) === 0o600n;
+}
+function retainUnixFeedbackAuthority(context) {
+  const bytes = Buffer.alloc(maximumStateBytes + 1);
+  let identity;
+  function readHeld(captureIdentity = false) {
+    let descriptor;
+    try {
+      descriptor = openSync(context.file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+      const stat = fstatSync(descriptor, { bigint: true });
+      if (!privateFeedbackFile(stat) || realpathSync2(context.file) !== context.file) {
+        return true;
+      }
+      if (captureIdentity) {
+        identity = stat;
+      }
+      if (!identity || stat.dev !== identity.dev || stat.ino !== identity.ino) {
+        return true;
+      }
+      const linked = lstatSync(context.file, { bigint: true });
+      if (!privateFeedbackFile(linked) || linked.dev !== identity.dev || linked.ino !== identity.ino || stat.size < 1n || stat.size > maximumStateSize) {
+        return true;
+      }
+      const length = readSync(descriptor, bytes, 0, bytes.length, 0);
+      if (BigInt(length) !== stat.size) {
+        return true;
+      }
+      const state = JSON.parse(bytes.toString("utf8", 0, length));
+      if (!state || typeof state !== "object" || Array.isArray(state)) {
+        return true;
+      }
+      const value = state;
+      const after = lstatSync(context.file, { bigint: true });
+      return !privateFeedbackFile(after) || after.dev !== identity.dev || after.ino !== identity.ino || value.schemaVersion !== context.schemaVersion || value.workspaceID !== context.workspaceID || value.generation !== context.generation || value.workspaceRoot !== context.workspaceRoot || typeof value.held !== "boolean" || value.held;
+    } catch {
+      return true;
+    } finally {
+      if (descriptor !== void 0) {
+        closeSync(descriptor);
+      }
+    }
+  }
+  return { initiallyHeld: readHeld(true), readHeld };
+}
+function feedbackAuthorityReader(context, raw) {
+  if (process.platform !== "win32") {
+    return retainUnixFeedbackAuthority(context);
+  }
+  return {
+    initiallyHeld: readViteFeedbackAuthority(raw),
+    readHeld: () => readViteFeedbackAuthority(raw)
+  };
+}
+function attachManagedViteFeedback(server, raw = process.env.OMNIVIEW_VITE_FEEDBACK) {
+  if (raw === void 0) {
+    return;
+  }
+  const context = feedbackContext(raw);
+  if (process.platform === "win32" && !context.authority) {
+    throw new Error("Managed Vite feedback on Windows requires its supervisor file authority");
+  }
+  const httpServer = server.httpServer;
+  const hmr = typeof server.config.server.hmr === "object" ? server.config.server.hmr : void 0;
+  if (!httpServer || Boolean(hmr?.server && hmr.server !== httpServer) || Boolean(hmr?.port && hmr.port !== server.config.server.port)) {
+    throw new Error("Managed Vite feedback requires HMR on its owned HTTP listener");
+  }
+  const authority = feedbackAuthorityReader(context, raw);
+  let closed = false;
+  let watchFailed = false;
+  let watcher;
+  let held = authority.initiallyHeld;
+  const pendingPings = /* @__PURE__ */ new Set();
+  function readHeld() {
+    return closed || watchFailed || authority.readHeld();
+  }
+  const originalWebSocketSend = server.ws.send;
+  function reloadConnectedConsumers() {
+    if (server.ws.clients.size > 0) {
+      originalWebSocketSend.call(server.ws, { type: "full-reload", path: "*" });
+    }
+  }
+  function releasePendingHTTPPings() {
+    for (const response of pendingPings) {
+      held = readHeld();
+      if (held) {
+        return "held";
+      }
+      pendingPings.delete(response);
+      response.writeHead(204).end();
+    }
+    return "released";
+  }
+  function refreshReadinessAndReleaseConsumers() {
+    const previouslyHeld = held;
+    held = readHeld();
+    if (held) {
+      return "held";
+    }
+    if (!previouslyHeld) {
+      return "ready";
+    }
+    held = readHeld();
+    if (held) {
+      return "held";
+    }
+    reloadConnectedConsumers();
+    return releasePendingHTTPPings();
+  }
+  const environments = server.environments;
+  const channels = /* @__PURE__ */ new Set([server.ws]);
+  for (const environment of Object.values(environments ?? {})) {
+    channels.add(environment.hot);
+  }
+  for (const channel of channels) {
+    const original = channel.send;
+    channel.send = function(payload, data) {
+      if (payload && typeof payload === "object" && "type" in payload && typeof payload.type === "string" && navigationTypes[payload.type]) {
+        if (refreshReadinessAndReleaseConsumers() !== "ready" || server.ws.clients.size === 0) {
+          return;
+        }
+      }
+      original.call(this, payload, data);
+    };
+  }
+  server.middlewares.use((request, response, next) => {
+    if (request.headers.accept !== "text/x-vite-ping") {
+      next();
+      return;
+    }
+    if (refreshReadinessAndReleaseConsumers() !== "held") {
+      response.writeHead(204).end();
+      return;
+    }
+    pendingPings.add(response);
+    response.once("close", () => pendingPings.delete(response));
+  });
+  const upgradeHandlers = /* @__PURE__ */ new Map();
+  for (const listener of httpServer.rawListeners("upgrade")) {
+    const original = listener;
+    const gated = function(request, socket, head) {
+      if (request.headers["sec-websocket-protocol"] === "vite-ping") {
+        if (refreshReadinessAndReleaseConsumers() === "held") {
+          socket.destroy();
+          return;
+        }
+      }
+      original.call(this, request, socket, head);
+    };
+    upgradeHandlers.set(original, gated);
+    httpServer.off("upgrade", original);
+    httpServer.on("upgrade", gated);
+  }
+  const originalClose = server.close;
+  function cleanup() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    watcher?.close();
+    for (const response of pendingPings) {
+      response.destroy();
+    }
+    pendingPings.clear();
+    for (const [original, gated] of upgradeHandlers) {
+      httpServer.off("upgrade", gated);
+      httpServer.on("upgrade", original);
+    }
+    httpServer.off("close", cleanup);
+    server.close = originalClose;
+  }
+  server.close = async function() {
+    cleanup();
+    await originalClose.call(this);
+  };
+  httpServer.once("close", cleanup);
+  try {
+    watcher = watch(context.file, { persistent: false }, () => {
+      refreshReadinessAndReleaseConsumers();
+    });
+    watcher.on("error", () => {
+      watchFailed = true;
+      held = true;
+    });
+    refreshReadinessAndReleaseConsumers();
+  } catch {
+    watchFailed = true;
+    held = true;
+  }
+}
+function managedViteFeedback() {
+  return {
+    name: "omniview-managed-vite-feedback",
+    apply: "serve",
+    enforce: "pre",
+    configureServer(server) {
+      attachManagedViteFeedback(server);
+    }
+  };
+}
+
 // src/index.ts
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var moduleDirectory = typeof __dirname === "string" ? __dirname : path3.dirname(fileURLToPath(import.meta.url));
 function getShimsDir() {
-  const packageRoot = path.resolve(__dirname, "..");
-  return path.join(packageRoot, "shims");
+  const packageRoot = path3.resolve(moduleDirectory, "..");
+  return path3.join(packageRoot, "shims");
 }
 function buildShimMap(shimsDir) {
   const map = /* @__PURE__ */ new Map();
   for (const pkg of SHARED_PACKAGES) {
-    const shimFile = path.join(shimsDir, `${safeFilename(pkg)}.mjs`);
+    const shimFile = path3.join(shimsDir, `${safeFilename(pkg)}.mjs`);
     map.set(pkg, shimFile);
   }
   return map;
@@ -75,7 +405,7 @@ function omniviewExternals(options = {}) {
   const shimMap = buildShimMap(shimsDir);
   if (options.additionalShared) {
     for (const pkg of options.additionalShared) {
-      const shimFile = path.join(shimsDir, `${safeFilename(pkg)}.mjs`);
+      const shimFile = path3.join(shimsDir, `${safeFilename(pkg)}.mjs`);
       shimMap.set(pkg, shimFile);
     }
   }
@@ -85,8 +415,55 @@ function omniviewExternals(options = {}) {
     enforce: "pre",
     // Run before other plugins (especially @vitejs/plugin-react)
     config(config, { command }) {
+      const cache = workspaceViteCacheDirectory(process.env.OMNIVIEW_VITE_CACHE_DIRECTORY);
+      if (cache) {
+        if (config.cacheDir && path3.resolve(config.root ?? process.cwd(), config.cacheDir) !== cache) {
+          throw new Error("Plugin Vite cache conflicts with its owned workspace cache");
+        }
+        config.cacheDir = cache;
+      }
+      const output = process.env.OMNIVIEW_BUILD_OUTPUT_DIRECTORY;
+      if (command === "build" && output) {
+        const root = path3.resolve(config.root ?? process.cwd());
+        const configured = config.build?.outDir && path3.resolve(root, config.build.outDir);
+        if (configured && configured !== path3.join(root, "dist") && configured !== path3.resolve(output)) {
+          throw new Error("Plugin distribution path conflicts with controlled workspace output");
+        }
+        config.build = { ...config.build, outDir: output };
+      }
       if (command === "serve") {
+        const roots = workspaceViteRoots(process.env.OMNIVIEW_VITE_ALLOWED_ROOTS);
+        const ownedPort = workspaceVitePort(process.env.OMNIVIEW_VITE_PORT);
+        if (roots) {
+          if (!ownedPort) {
+            throw new Error("Managed plugin Vite requires its owned OMNIVIEW_VITE_PORT");
+          }
+          config.server = config.server ?? {};
+          if (config.server.port !== void 0 && config.server.port !== ownedPort) {
+            throw new Error("Plugin Vite port conflicts with its owned workspace lease");
+          }
+          if (config.server.hmr === false || typeof config.server.hmr === "object" && (config.server.hmr.clientPort !== void 0 && config.server.hmr.clientPort !== ownedPort || config.server.hmr.port !== void 0 && config.server.hmr.port !== ownedPort || config.server.hmr.host !== void 0 && config.server.hmr.host !== "127.0.0.1" || config.server.hmr.protocol !== void 0 && config.server.hmr.protocol !== "ws")) {
+            throw new Error("Plugin Vite HMR conflicts with its owned loopback endpoint");
+          }
+          config.server.port = ownedPort;
+          config.server.strictPort = true;
+          config.server.fs = {
+            ...config.server.fs,
+            strict: true,
+            allow: [.../* @__PURE__ */ new Set([...config.server.fs?.allow ?? [config.root ?? process.cwd()], ...roots, shimsDir])]
+          };
+          config.server.hmr = {
+            ...typeof config.server.hmr === "object" ? config.server.hmr : {},
+            host: "127.0.0.1",
+            protocol: "ws",
+            clientPort: ownedPort
+          };
+        }
         config.optimizeDeps = config.optimizeDeps ?? {};
+        config.optimizeDeps.exclude = [.../* @__PURE__ */ new Set([...config.optimizeDeps.exclude ?? [], ...allPackages])];
+        if (roots) {
+          config.optimizeDeps.force = true;
+        }
         config.optimizeDeps.esbuildOptions = config.optimizeDeps.esbuildOptions ?? {};
         config.optimizeDeps.esbuildOptions.plugins = [
           ...config.optimizeDeps.esbuildOptions.plugins ?? [],
@@ -116,21 +493,41 @@ function omniviewExternals(options = {}) {
         } else if (typeof existing === "function") {
           const originalFn = existing;
           config.build.rollupOptions.external = (source, importer, isResolved) => {
-            if (sharedSet.has(source)) return true;
+            if (sharedSet.has(source)) {
+              return true;
+            }
             return originalFn(source, importer, isResolved);
           };
         } else if (existing === void 0 || existing === null) {
           config.build.rollupOptions.external = [...allPackages];
         } else {
           config.build.rollupOptions.external = (source) => {
-            if (sharedSet.has(source)) return true;
-            if (typeof existing === "string") return source === existing;
-            if (existing instanceof RegExp) return existing.test(source);
+            if (sharedSet.has(source)) {
+              return true;
+            }
+            if (typeof existing === "string") {
+              return source === existing;
+            }
+            if (existing instanceof RegExp) {
+              return existing.test(source);
+            }
             return false;
           };
         }
       }
     },
+    configResolved(config) {
+      if (config.command !== "serve" || !config.optimizeDeps.include) {
+        return;
+      }
+      config.optimizeDeps.include = config.optimizeDeps.include.filter((dependency) => {
+        const target = dependency.slice(dependency.lastIndexOf(">") + 1).trim();
+        return !sharedSet.has(target);
+      });
+    },
+    configureServer(server) {
+      attachManagedViteFeedback(server);
+    },
     resolveId(source) {
       if (sharedSet.has(source)) {
         const shimPath = shimMap.get(source);
@@ -146,6 +543,7 @@ var index_default = omniviewExternals;
 export {
   SHARED_PACKAGES,
   index_default as default,
+  managedViteFeedback,
   omniviewExternals,
   safeFilename
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omniviewdev/vite-plugin",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Vite plugin for Omniview plugin development. Redirects shared dependency imports to the host app's singleton instances via window.__OMNIVIEW_SHARED__.",
   "license": "AGPL-3.0-only",
   "author": "Omniview",
@@ -19,7 +19,7 @@
     "shims"
   ],
   "scripts": {
-    "build": "pnpm run generate-shims && pnpm run check-shims && tsup src/index.ts --format esm,cjs --dts --clean",
+    "build": "pnpm run generate-shims && pnpm run check-shims && node ../../scripts/build-tsup.mjs src/index.ts --format esm,cjs --dts --clean",
     "check-shims": "tsx scripts/check-shim-exports.ts",
     "generate-shims": "tsx scripts/generate-shims.ts",
     "test": "tsx --test scripts/*.test.ts",

package/shims/_omniviewdev__base-ui.mjs

@@ -18,6 +18,8 @@ export const AspectRatio = mod.AspectRatio;
 export const Autocomplete = mod.Autocomplete;
 export const Avatar = mod.Avatar;
 export const AvatarGroup = mod.AvatarGroup;
+export const BUILT_IN_THEMES = mod.BUILT_IN_THEMES;
+export const BUILT_IN_THEME_IDS = mod.BUILT_IN_THEME_IDS;
 export const BUILT_IN_THEME_MODES = mod.BUILT_IN_THEME_MODES;
 export const Badge = mod.Badge;
 export const Banner = mod.Banner;
@@ -120,6 +122,7 @@ export const TextArea = mod.TextArea;
 export const TextField = mod.TextField;
 export const ThemeProvider = mod.ThemeProvider;
 export const ThemeSwitcher = mod.ThemeSwitcher;
+export const ThemeValidationError = mod.ThemeValidationError;
 export const TimeColumns = mod.TimeColumns;
 export const TimePicker = mod.TimePicker;
 export const Timeline = mod.Timeline;
@@ -134,10 +137,12 @@ export const Underline = mod.Underline;
 export const buildSections = mod.buildSections;
 export const computeTabSegments = mod.computeTabSegments;
 export const createThemeRegistry = mod.createThemeRegistry;
+export const createThemeRootApplier = mod.createThemeRootApplier;
 export const fileTypeLabel = mod.fileTypeLabel;
 export const formatBytes = mod.formatBytes;
 export const formatDate = mod.formatDate;
 export const getDaysInMonth = mod.getDaysInMonth;
+export const isBuiltInThemeId = mod.isBuiltInThemeId;
 export const isLeapYear = mod.isLeapYear;
 export const statusToColor = mod.statusToColor;
 export const themeRegistry = mod.themeRegistry;
@@ -171,5 +176,6 @@ export const useTreeConfig = mod.useTreeConfig;
 export const useTreeItem = mod.useTreeItem;
 export const useTreeStoreContext = mod.useTreeStoreContext;
 export const validateSections = mod.validateSections;
+export const validateThemeDefinition = mod.validateThemeDefinition;
 
 export default mod.default !== undefined ? mod.default : mod;

package/shims/_omniviewdev__runtime__api.mjs

@@ -14,6 +14,7 @@ export const DataClient = mod.DataClient;
 export const DevServerManager = mod.DevServerManager;
 export const DiagnosticsClient = mod.DiagnosticsClient;
 export const ExecClient = mod.ExecClient;
+export const GetInstanceInfo = mod.GetInstanceInfo;
 export const GetOperatingSystem = mod.GetOperatingSystem;
 export const GraphClient = mod.GraphClient;
 export const LogsClient = mod.LogsClient;

package/shims/_omniviewdev__runtime__models.mjs

@@ -37,7 +37,6 @@ export const DeleteInput = mod.DeleteInput;
 export const DeleteResult = mod.DeleteResult;
 export const DependencyNode = mod.DependencyNode;
 export const DependencyTree = mod.DependencyTree;
-export const DevInfoFile = mod.DevInfoFile;
 export const DevProcessStatus = mod.DevProcessStatus;
 export const DevServerErrorPayload = mod.DevServerErrorPayload;
 export const DevServerLogEntry = mod.DevServerLogEntry;
@@ -67,6 +66,7 @@ export const GraphNode = mod.GraphNode;
 export const Handler = mod.Handler;
 export const HealthCondition = mod.HealthCondition;
 export const HealthStatus = mod.HealthStatus;
+export const LifecycleStage = mod.LifecycleStage;
 export const ListInput = mod.ListInput;
 export const ListResult = mod.ListResult;
 export const LogSession = mod.LogSession;
@@ -120,6 +120,7 @@ export const Setting = mod.Setting;
 export const SettingFileSelection = mod.SettingFileSelection;
 export const SettingOption = mod.SettingOption;
 export const SettingType = mod.SettingType;
+export const StateIsolationProvenance = mod.StateIsolationProvenance;
 export const Subgraph = mod.Subgraph;
 export const SubgraphNode = mod.SubgraphNode;
 export const TimeSeries = mod.TimeSeries;
@@ -143,6 +144,7 @@ export const time = mod.time;
 export const types = mod.types;
 export const ui = mod.ui;
 export const utils = mod.utils;
+export const DevInfoFile = mod.DevInfoFile;
 export const main = mod.main;
 export const plugin = mod.plugin;