lecodes-cli 0.19.2 → 0.20.1

package/src/peers.ts

@@ -1,26 +1,49 @@
 import { existsSync, readFileSync } from "node:fs"
 import { createRequire } from "node:module"
-import { dirname, join } from "node:path"
-
-/* Optional peer packages a user installs separately — `npm install -g …`, matching how the CLI
- * itself is installed. A bare specifier resolves upward from the importing FILE, so a global CLI
- * only ever sees globally installed peers: a project-local `-D` install is invisible to it, and
- * under `npx` neither works (pass every peer as its own `-p`). `--version` reports each one's
- * installed version so a stale/mismatched copy — the usual cause of "needs X" errors or silent
- * render failures like a design screen coming back empty — is visible at a glance. The probe is an
- * export subpath that resolves to a real file in BOTH the published package and the workspace
- * source, so version reporting works whether the CLI runs from npm or straight from the monorepo. */
+import { homedir } from "node:os"
+import { dirname, join, resolve } from "node:path"
+
+/* Optional peer packages the CLI loads lazily. Two places they can live:
+ *
+ *   global   `npm install -g …`, next to a globally installed CLI — the original way. A bare specifier
+ *            resolves upward from the importing FILE, so a global CLI only ever sees globally installed
+ *            peers (a project-local `-D` install is invisible to it).
+ *   prefix   ~/.lecodes/peers (LECODES_PEERS_DIR) — the CLI's own install dir, filled ON FIRST USE by
+ *            peerInstall.ts when a command needs a peer that isn't there: no admin rights, and the
+ *            runtime-set peer (lecodes-renderer) is pinned to THIS CLI's version, so the compiler and
+ *            the headless host can't drift apart. `@napi-rs/canvas` (PNG output) rides along with it.
+ *
+ * Global wins when both exist (it is what the user chose by hand). `--version` reports each peer's
+ * installed version + where it came from, so a stale/mismatched copy — the usual cause of "needs X"
+ * errors or a design screen rendering empty — is visible at a glance. The probe is an export subpath
+ * that resolves to a real file in BOTH the published package and the workspace source. */
 export const OPTIONAL_PEERS: [name: string, probe: string][] = [
   ["lecodes-renderer", "lecodes-renderer/headless"],
   ["lecodes-design", "lecodes-design/server"],
   ["lecodes-3d-editor", "lecodes-3d-editor/server"],
   ["lecodes-assets", "lecodes-assets/cli"],
+  ["@napi-rs/canvas", "@napi-rs/canvas"],
 ]
 
-/** Installed version of an optional peer, or null when it isn't installed. Resolves the probe
- *  subpath, then walks up to the nearest package.json that actually names the package (skipping any
- *  nested ones). Never throws — a standalone binary with no node_modules reports every peer absent. */
-export const peerVersion = (name: string, probe: string): string | null => {
+/** The CLI's own peer install dir. */
+export const peersDir = (): string =>
+  process.env.LECODES_PEERS_DIR ? resolve(process.env.LECODES_PEERS_DIR) : join(homedir(), ".lecodes", "peers")
+
+/** Where a peer sits inside the prefix (scoped names span two directories). */
+export const peerDirInPrefix = (name: string): string => join(peersDir(), "node_modules", ...name.split("/"))
+
+const readVersion = (dir: string): string | null => {
+  try {
+    return (JSON.parse(readFileSync(join(dir, "package.json"), "utf8")) as { version?: string }).version ?? "unknown"
+  } catch {
+    return null
+  }
+}
+
+/** Installed version of a peer as a bare specifier resolves it (global / workspace), or null. Resolves
+ *  the probe subpath, then walks up to the nearest package.json that actually names the package
+ *  (skipping any nested ones). Never throws — a standalone binary with no node_modules reports absent. */
+export const peerVersionGlobal = (name: string, probe: string): string | null => {
   try {
     const require = createRequire(import.meta.url)
     let dir = dirname(require.resolve(probe))
@@ -38,3 +61,14 @@ export const peerVersion = (name: string, probe: string): string | null => {
   return null
 }
 
+/** Installed version of a peer in the CLI's own prefix, or null. */
+export const peerVersionPrefix = (name: string): string | null => readVersion(peerDirInPrefix(name))
+
+/** Installed version of a peer wherever it lives (global first), or null when it isn't installed. */
+export const peerVersion = (name: string, probe: string): string | null =>
+  peerVersionGlobal(name, probe) ?? peerVersionPrefix(name)
+
+/** Which install a bare load of the peer would hit: "global" (npm -g / the workspace), "prefix"
+ *  (~/.lecodes/peers), or null when it is nowhere. */
+export const peerSource = (name: string, probe: string): "global" | "prefix" | null =>
+  peerVersionGlobal(name, probe) !== null ? "global" : peerVersionPrefix(name) !== null ? "prefix" : null

package/src/projectEnv.ts

@@ -69,7 +69,11 @@ export const applyDotEnv = (
 /** The nearest project root at or above `start`: the first dir with app.json or .lecodes/. */
 export const findEnvRoot = (start: string): string | null => {
   let dir = resolve(start)
+  // The home dir holds the CLI's own ~/.lecodes (matc, desktop host, peers) — never a project, and a
+  // `~/.env` must not be loaded as one (update.ts's findProjectDir draws the same line).
+  const home = resolve(homedir())
   while (true) {
+    if (dir === home) return null
     if (existsSync(join(dir, "app.json")) || existsSync(join(dir, ".lecodes"))) return dir
     const parent = dirname(dir)
     if (parent === dir) return null

package/src/releases.ts

@@ -43,6 +43,22 @@ export const semverNewer = (a: string, b: string): number => {
   return 0
 }
 
+/**
+ * The newest published version that actually carries a build for this platform — NOT the product's
+ * `latest`. A release ships the platforms whose machine ran it: matc 1.4.0 is windows-x64 alone, and
+ * its macOS build lives on 1.3.2. Keying off `latest` therefore reports "isn't published" to everyone
+ * whose platform missed the last release, even though a perfectly good older build is right there.
+ * Null when the platform has never been published at all. (These tools are deliberately version-loose:
+ * a filamat is tied to the vendored Filament, which changes rarely — see matcTool's header.)
+ */
+export const newestForPlatform = (
+  versions: ManifestVersion[], key: string,
+): { version: string, file: ManifestFile } | null => {
+  const carrying = versions.filter((v) => v.files[key]).sort((a, b) => semverNewer(a.version, b.version))
+  const newest = carrying[0]
+  return newest ? { version: newest.version, file: newest.files[key]! } : null
+}
+
 /** One product from the release manifest (always fetched fresh — see MANIFEST_URL). */
 export const fetchReleaseProduct = async (
   product: string, label: string,