lecodes-cli 2.0.5 → 2.0.6

package/src/compile/projectCompile.ts

@@ -3,6 +3,8 @@ import { createRequire } from "node:module"
 import { dirname, join } from "node:path"
 import type { FileKind } from "../project/manifest"
 import { distRoot } from "../hosts/distRoot"
+import { installPeers } from "../hosts/peerInstall"
+import { peerDirInPrefix } from "../hosts/peers"
 import {
   compileProject as sdkCompileProject, compileServerBundle, detectEntry, isServerPath, scanModulesChisel, localAssetNames, ENTRY_CONVENTION,
   type CompileServerOptions,
@@ -123,40 +125,39 @@ export const compileProject = (opts: CompileOptions): Promise<string> =>
 export const hasServerFiles = (entries: CompileEntry[]): boolean =>
   entries.some((e) => e.type === "text" && isServerPath(e.path))
 
-/** TypeScript with its lib files on disk — the endpoint validators are derived by its checker. The
- *  project's own, else what this CLI's install can see; null when there is none. */
-const findTypescript = (root: string): CompileServerOptions["typescript"] | null => {
-  for (const from of [join(root, "package.json"), import.meta.url]) {
+type Typescript = NonNullable<CompileServerOptions["typescript"]>
+
+/** TypeScript with its lib files on disk — the server code is checked, and the endpoint validators
+ *  derived, by its checker. The project's own, else one this CLI's install can see, else the CLI's
+ *  peer (installed on first use, like the database engine). One WITHOUT the compiler API is passed
+ *  over: TypeScript 7 — what `install typescript` brings today — is the native compiler, with no
+ *  `createProgram` to call. */
+const findTypescript = async (root: string): Promise<Typescript> => {
+  const from = (at: string): Typescript | null => {
     try {
-      const mod = createRequire(from)("typescript")
-      const ts = mod?.createProgram ? mod : mod?.default
-      if (ts?.createProgram) return ts
-    } catch { /* the next place */ }
+      const mod = createRequire(at)("typescript")
+      return mod?.createProgram ? mod : mod?.default?.createProgram ? mod.default : null
+    } catch { return null }
   }
-  return null
+  const prefix = join(peerDirInPrefix("typescript"), "package.json")
+  const found = from(join(root, "package.json")) ?? from(import.meta.url) ?? from(prefix)
+  if (found) return found
+  await installPeers(["typescript"], "The project's server code (*.server.ts)")
+  return from(prefix) ?? (() => { throw new Error(`The typescript installed in ${peerDirInPrefix("typescript")} has no compiler API`) })()
 }
 
 /**
  * The project's server bundle (its `*.server.ts` files and what they import), or null when it has
- * none. `app` = app.json's name (the sign-in mail). Without a TypeScript to derive them with the
- * bundle carries no argument validators — said through `onWarning`, since the deployed backend
- * (the le.codes build) does check them.
+ * none. `app` = app.json's name (the sign-in mail). Always checked with TypeScript, the way the
+ * le.codes build checks it: an endpoint that is not async, an unawaited `requireUser()` are errors
+ * only the checker finds.
  */
-export const compileServer = async (opts: { entries: CompileEntry[], root: string, app?: CompileServerOptions["app"], onWarning?: (message: string) => void }) => {
-  const typescript = findTypescript(opts.root)
-  if (!typescript) {
-    // Sign-in rests on a check only the compiler makes: `db.auth.requireUser()` is a query, and one that is
-    // not awaited guards nothing. A server with sign-in is not built without it.
-    const signIn = opts.entries.find((e) => e.type === "text" && isServerPath(e.path) && /\.withAuth\s*\(/.test(e.text ?? ""))
-    if (signIn) throw new Error(`${signIn.path} uses sign-in (withAuth): its server code is checked with TypeScript, and none was found — npm install --save-dev typescript in the project.`)
-    opts.onWarning?.("Endpoint arguments are not checked against their types here: no TypeScript found (npm install --save-dev typescript in the project).")
-  }
-  return compileServerBundle({
+export const compileServer = async (opts: { entries: CompileEntry[], root: string, app?: CompileServerOptions["app"] }) =>
+  compileServerBundle({
     entries: opts.entries.map((e) => ({ path: e.path, type: e.type as any, text: e.text })),
     app: opts.app,
-    ...(typescript ? { typescript } : { validate: false }),
+    typescript: await findTypescript(opts.root),
   })
-}
 
 /** Re-exported so the CALLERS that stage files next to the bundle name them the way the bundle asks
  *  for them (see localAssetNames in the SDK compile — two packs shipping SM_Sign_01.glb). */

package/src/dev/devServer.ts

@@ -187,7 +187,7 @@ export const startDevServer = async (options: DevServerOptions): Promise<DevServ
         if (ambiguous) warnings.push(ambiguous)
       }
       const onWarning = (w: string) => { warnings.push(w) }
-      const serverBundle = await backend.compile(entries, onWarning)
+      const serverBundle = await backend.compile(entries)
       const js = await compileProject({ entries, name, publicUrl: origin, entryOverride, header: true, fontsHeader, iconsHeader, onWarning, serverUrl: serverBundle ? serverUrl : undefined })
       // the backend takes the new bundle once the app compiled, and before devices are told to reload
       warnings.push(...await backend.run(serverBundle))

package/src/dev/projectBackend.ts

@@ -33,7 +33,7 @@ export type ProjectBackendOptions = {
 
 export type ProjectBackend = {
   /** The server bundle of these entries; null when the project has no server files. */
-  compile: (entries: CompileEntry[], onWarning: (w: string) => void) => Promise<ServerBundle | null>
+  compile: (entries: CompileEntry[]) => Promise<ServerBundle | null>
   /** Run this bundle from now on (null = the project has no server side any more: stop). Rejects
    *  when it does not load; resolves to what to tell the developer. */
   run: (bundle: ServerBundle | null) => Promise<string[]>
@@ -75,11 +75,11 @@ export const createProjectBackend = (options: ProjectBackendOptions): ProjectBac
   const envelope = (body: unknown) => new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json", "cache-control": "no-store", ...CORS } })
 
   return {
-    compile: async (entries, onWarning) => {
+    compile: async (entries) => {
       if (!hasServerFiles(entries)) return null
       // the app's name, for the sign-in mail
       const app = readAppConfigAt(root)
-      return compileServer({ entries, root, app: app ? { name: app.name } : undefined, onWarning })
+      return compileServer({ entries, root, app: app ? { name: app.name } : undefined })
     },
     run: async (bundle) => {
       if (!bundle) {
@@ -182,7 +182,7 @@ export const runBackend = (options: { root: string, command: string, log: (msg:
 
   return {
     start: async (entries, onWarning) => {
-      const bundle = await backend.compile(entries, onWarning)
+      const bundle = await backend.compile(entries)
       if (!bundle) return undefined
       for (const w of await backend.run(bundle)) onWarning(w)
       // the project's port when it is free (two runs of one project at once: the second takes any)

package/src/hosts/packageManager.ts

@@ -0,0 +1,45 @@
+import { spawnSync } from "node:child_process"
+import { homedir } from "node:os"
+import { join, resolve, sep } from "node:path"
+import { fileURLToPath } from "node:url"
+
+/*
+ * ONE answer to "which package manager installs things for this CLI": the one the CLI itself was
+ * installed with. A CLI under bun's global dir (`bun install -g lecodes-cli`) installs its peers and
+ * updates itself with bun; any other install goes through npm. Mixing them is the failure this
+ * removes: `npm install -g lecodes-cli@latest` beside a bun-installed CLI puts a SECOND copy in npm's
+ * prefix and leaves the `lecodes` on PATH as old as it was.
+ */
+export type PackageManager = "npm" | "bun"
+
+const onPath = (cmd: string): boolean => {
+  try { return spawnSync(cmd, ["--version"], { stdio: "ignore", shell: process.platform === "win32" }).status === 0 } catch { return false }
+}
+
+/** Bun's global install dir (`BUN_INSTALL` moves it). */
+const bunGlobalDir = (): string => join(process.env.BUN_INSTALL ? resolve(process.env.BUN_INSTALL) : join(homedir(), ".bun"), "install", "global")
+
+/** The manager that owns the install this file runs from. */
+export const ownManager = (file = fileURLToPath(import.meta.url)): PackageManager => {
+  const norm = (p: string) => process.platform === "win32" ? p.toLowerCase() : p
+  return norm(resolve(file)).startsWith(norm(bunGlobalDir()) + sep) ? "bun" : "npm"
+}
+
+/** The manager to install with: the CLI's own, else whichever of the two is on PATH; null = neither. */
+export const pickManager = (): PackageManager | null => {
+  const own = ownManager()
+  const other = own === "npm" ? "bun" : "npm"
+  return onPath(own) ? own : onPath(other) ? other : null
+}
+
+/** `<tool> <argv>` that installs `specs` into the directory `dir` (a private prefix with a package.json). */
+export const installIntoArgv = (tool: PackageManager, dir: string, specs: string[]): string[] =>
+  tool === "npm" ? ["install", "--prefix", dir, "--no-audit", "--no-fund", "--loglevel=error", ...specs] : ["add", "--cwd", dir, ...specs]
+
+/** `<tool> <argv>` that installs `specs` globally. */
+export const installGlobalArgv = (tool: PackageManager, specs: string[]): string[] =>
+  tool === "npm" ? ["install", "-g", ...specs] : ["add", "-g", ...specs]
+
+/** The same, as a line a person can run. */
+export const commandLine = (tool: PackageManager, argv: string[]): string =>
+  `${tool} ${argv.map((a) => /\s/.test(a) ? `"${a}"` : a).join(" ")}`

package/src/hosts/peerInstall.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url"
 import pkg from "../../package.json"
 import { peerDirInPrefix, peersDir, peerVersionGlobal } from "./peers"
 import { archiveSpec } from "./archives"
+import { commandLine, installGlobalArgv, installIntoArgv, ownManager, pickManager } from "./packageManager"
 import { CliError, c, confirm, log, note } from "../cli"
 
 /*
@@ -19,8 +20,9 @@ import { CliError, c, confirm, log, note } from "../cli"
  *
  * Consent: an interactive terminal is asked (default yes); `--yes` / `-y` on any command or
  * LECODES_YES=1 (CI) skips the question; a non-interactive run without either fails with the exact
- * command to run by hand. Installer: npm if on PATH, else bun; neither → a clear error (the standalone
- * binary on a machine without Node can't install packages — it says so).
+ * command to run by hand. Installer: the package manager this CLI was installed with (./packageManager.ts
+ * — bun for a `bun install -g` CLI, npm otherwise), else the other one; neither → a clear error (the
+ * standalone binary on a machine without Node can't install packages — it says so).
  *
  * Search order when a command needs a peer: the bare specifier (global / the workspace — what the
  * user installed by hand always wins) → the prefix → install into the prefix, then load from there.
@@ -48,12 +50,7 @@ export const peerSpec = async (name: string): Promise<string> => {
 /** Peers that only make sense together: the renderer's PNG output needs canvas next to it. */
 const companions = (name: string): string[] => name === "lecodes-headless" ? ["lecodes-headless", "@napi-rs/canvas"] : [name]
 
-const onPath = (cmd: string): boolean => {
-  try { return spawnSync(cmd, ["--version"], { stdio: "ignore", shell: process.platform === "win32" }).status === 0 } catch { return false }
-}
-const pickInstaller = (): "npm" | "bun" | null => onPath("npm") ? "npm" : onPath("bun") ? "bun" : null
-
-const manualCommand = (dir: string, specs: string[]) => `npm install --prefix "${dir}" ${specs.join(" ")}`
+const manualCommand = (dir: string, specs: string[]) => commandLine(ownManager(), installIntoArgv(ownManager(), dir, specs))
 
 /**
  * Install peers into the prefix. Asks for consent unless `opts.yes` / LECODES_YES / `--yes` say so;
@@ -86,14 +83,12 @@ export const installPeers = async (names: string[], why: string, opts: { yes?: b
     }
   }
 
-  const tool = pickInstaller()
+  const tool = pickManager()
   if (!tool) throw new CliError(`Neither npm nor bun is on PATH, so ${names.join(" + ")} can't be installed automatically. Install one, or run on a machine with Node:  ${manualCommand(dir, specsNow)}`)
 
   for (const name of ordered) {
     const spec = await peerSpec(name) // canvas's range comes from the renderer installed a step earlier
-    const argv = tool === "npm"
-      ? ["install", "--prefix", dir, "--no-audit", "--no-fund", "--loglevel=error", spec]
-      : ["add", "--cwd", dir, spec]
+    const argv = installIntoArgv(tool, dir, [spec])
     note(`$ ${tool} ${argv.join(" ")}`)
     const r = spawnSync(tool, argv, { stdio: "inherit", shell: process.platform === "win32", timeout: 10 * 60_000 })
     if (r.error) throw new CliError(`${tool} could not run: ${r.error.message}`)
@@ -157,7 +152,7 @@ export async function loadPeer<T>(name: string, subpath: string | undefined, opt
     if (opts.install === false) return null
     // A global install of a DIFFERENT version than the probe expects would have resolved above; here
     // the peer is nowhere. (Globally installed but broken → the error above was not "not found".)
-    if (peerVersionGlobal(name, spec) !== null) throw new CliError(`${name} is installed but "${spec}" can't be loaded from it — reinstall it: npm install -g ${await peerSpec(name)}`)
+    if (peerVersionGlobal(name, spec) !== null) throw new CliError(`${name} is installed but "${spec}" can't be loaded from it — reinstall it: ${commandLine(ownManager(), installGlobalArgv(ownManager(), [await peerSpec(name)]))}`)
     await installPeers(companions(name), opts.for)
   }
   return (await import(pathToFileURL(resolveEntry(dir, subpath)).href)) as T

package/src/hosts/peers.ts

@@ -24,6 +24,7 @@ export const OPTIONAL_PEERS: [name: string, probe: string][] = [
   ["lecodes-assets", "lecodes-assets/cli"],
   ["@napi-rs/canvas", "@napi-rs/canvas"],
   ["marcidb-embedded", "marcidb-embedded"],
+  ["typescript", "typescript"],
 ]
 
 /** The CLI's own peer install dir. */