lecodes-cli 0.20.1 → 1.0.0

package/src/commands/update.ts

@@ -1,211 +0,0 @@
-import { spawnSync } from "node:child_process"
-import { existsSync, readdirSync } from "node:fs"
-import { homedir } from "node:os"
-import { dirname, join, resolve } from "node:path"
-import pkg from "../../package.json"
-import { CliError, c, flagBool, log, note, type Args } from "../util"
-import { OPTIONAL_PEERS, peerSource, peerVersion } from "../peers"
-import { installPeers } from "../peerInstall"
-import { updateDesktop } from "../desktopRenderer"
-import { updateMatc } from "../matcTool"
-import { types } from "./types"
-import { shaders } from "./shaders"
-import { app } from "./app"
-
-/*
- * `lecodes update` — one command that moves EVERYTHING a project depends on to its newest published
- * state, in the order the pieces depend on each other:
- *
- *   1. desktop   the LeCodes Desktop host `desktop run` / `render --desktop` use   (= `desktop update`)
- *   2. matc      Filament's material compiler for local shader compiles              (= `shaders update`)
- *   3. shaders   recompile the project's .mat files with that matc                   (= `shaders compile`)
- *   4. types     the IDE types (.lecodes/types + tsconfig) from the server            (= `types`)
- *   5. shells    ios/ + android/ pins → newest SDK release + plugin tags, re-sync     (= `app update`)
- *   6. cli       the npm installs — every installed optional peer (lecodes-renderer, lecodes-design,
- *                lecodes-3d-editor, lecodes-assets, @napi-rs/canvas) and the CLI itself that is behind:
- *                peers in ~/.lecodes/peers (first-use installs, peerInstall.ts) are re-installed there
- *                — the renderer at THIS CLI's version, the rest at npm's latest in range; global ones
- *                (`npm install -g`, the old way) via `npm install -g …@latest`; the CLI itself last
- *                (the standalone binary can't come from npm — it says so and does the peers only)
- *
- * Every step is the existing subcommand, so nothing here can drift from what the individual
- * commands do; this only sequences them and keeps going when one fails (the summary says which).
- * Steps that the environment pins are SKIPPED, not overridden: LECODES_DESKTOP_EXE means a local
- * host build (engine work — the cache is irrelevant), LECODES_MATC a local matc; the project steps
- * need a project (a dir with app.json / .lecodes above the cwd) and the shell step a shell folder.
- *
- * Flags: --local (types from the SDK bundled in this CLI instead of the server), --no-shells (leave
- * ios/android pins alone — `app update` re-syncs, which compiles the bundle and, for server projects,
- * needs a login), --check (the npm step only REPORTS what is behind and prints the install line),
- * --no-cli (skip the npm step — offline / air-gapped machines).
- *
- * `lecodes types` used to be its own command; the types step here replaced it (2026-09-04).
- */
-
-/** The nearest project at or above `start`: a dir with app.json, or a .lecodes/ that holds a project's
- *  manifest or types. NOT the bare `.lecodes/` marker projectEnv uses — the CLI's own config lives in
- *  ~/.lecodes, so that rule would turn any folder under the home dir into a "project" and the types
- *  step would scaffold .lecodes/types + tsconfig.json into it. */
-const findProjectDir = (start: string): string | null => {
-  const home = resolve(homedir())
-  let dir = resolve(start)
-  while (true) {
-    if (dir !== home && (existsSync(join(dir, "app.json")) || existsSync(join(dir, ".lecodes", "manifest.json")) || existsSync(join(dir, ".lecodes", "types")))) return dir
-    const parent = dirname(dir)
-    if (parent === dir) return null
-    dir = parent
-  }
-}
-
-type Outcome = "updated" | "ok" | "skipped" | "failed"
-type Step = { name: string, outcome: Outcome, detail?: string }
-
-const NPM = "https://registry.npmjs.org"
-
-/** `latest` dist-tag of an npm package, or null when npm is unreachable / the package is unknown. */
-const npmLatest = async (name: string): Promise<string | null> => {
-  try {
-    const res = await fetch(`${NPM}/${name}/latest`, { signal: AbortSignal.timeout(4000) })
-    if (!res.ok) return null
-    const json = await res.json() as { version?: string }
-    return json.version ?? null
-  } catch {
-    return null
-  }
-}
-
-const semverNewer = (a: string, b: string): number => {
-  const pa = a.split(/[.-]/).map(Number), pb = b.split(/[.-]/).map(Number)
-  for (let i = 0; i < 3; i++) { const d = (pa[i] ?? 0) - (pb[i] ?? 0); if (d) return d }
-  return 0
-}
-
-/** Running straight from the repo checkout (src/commands/update.ts), not a built dist/binary. */
-const FROM_SOURCE = /[\\/]src[\\/]commands[\\/]/.test(import.meta.url)
-/** The standalone release build: the bundle + chisel sit next to the executable (same test as index.ts). */
-const STANDALONE = existsSync(join(dirname(process.execPath), "runtime")) &&
-  existsSync(join(dirname(process.execPath), process.platform === "win32" ? "chisel.exe" : "chisel"))
-
-export const update = async (args: Args) => {
-  const steps: Step[] = []
-  const heading = (name: string, what: string) => log(`\n${c.bold(name)}  ${c.dim(what)}`)
-  const run = async (name: string, what: string, fn: () => Promise<Outcome | [Outcome, string]>) => {
-    heading(name, what)
-    try {
-      const r = await fn()
-      const [outcome, detail] = Array.isArray(r) ? r : [r, undefined]
-      steps.push({ name, outcome, detail })
-      if (outcome === "skipped" && detail) note(`skipped — ${detail}`)
-    } catch (e) {
-      const msg = e instanceof CliError ? e.message : e instanceof Error ? e.message : String(e)
-      log(c.red("✗ ") + msg)
-      steps.push({ name, outcome: "failed", detail: msg })
-    }
-  }
-
-  const root = findProjectDir(process.cwd())
-
-  // 1. desktop host
-  await run("desktop", "LeCodes Desktop host (desktop run / render --desktop)", async () => {
-    if (process.env.LECODES_DESKTOP_EXE) return ["skipped", `LECODES_DESKTOP_EXE=${process.env.LECODES_DESKTOP_EXE} (a local build; \`lecodes desktop update\` refreshes the cache anyway)`]
-    await updateDesktop()
-    return "ok"
-  })
-
-  // 2. matc
-  await run("matc", "Filament material compiler for local shader compiles", async () => {
-    if (process.env.LECODES_MATC) return ["skipped", `LECODES_MATC=${process.env.LECODES_MATC} (a local matc)`]
-    await updateMatc()
-    return "ok"
-  })
-
-  // 3. shaders (project)
-  await run("shaders", "recompile the project's .mat shaders with the current matc", async () => {
-    if (!root) return ["skipped", "not inside a project"]
-    await shaders({ _: ["compile"], flags: {} })
-    return "ok"
-  })
-
-  // 4. types (project)
-  await run("types", flagBool(args, "local") ? "IDE types from the SDK bundled in this CLI" : "IDE types from the server", async () => {
-    if (!root) return ["skipped", "not inside a project"]
-    await types({ _: [], flags: flagBool(args, "local") ? { local: true } : {} })
-    return "ok"
-  })
-
-  // 5. native shells (project)
-  await run("shells", "ios/ + android/ pins → newest SDK release + plugin tags, then re-sync", async () => {
-    if (!root) return ["skipped", "not inside a project"]
-    if (flagBool(args, "no-shells")) return ["skipped", "--no-shells"]
-    const present = ["ios", "android"].filter((d) => existsSync(join(root!, d)) && readdirSync(join(root!, d)).length > 0)
-    if (present.length === 0) return ["skipped", "no ios/ or android/ shell in this project (`lecodes app init ios|android`)"]
-    await app({ _: ["update"], flags: {} })
-    return "ok"
-  })
-
-  // 6. this CLI + its optional peers — the GLOBAL npm installs (`npm install -g`, how the CLI and its
-  // peers are installed): every installed one that is behind npm's latest moves forward. The peers go
-  // first, the CLI itself last — replacing the running CLI's files is fine (this process already
-  // holds its code), but its new version is what the next invocation runs, so nothing after it here.
-  // Peers that are NOT installed stay that way: they're optional, installing one is a choice.
-  await run("cli", "lecodes-cli + its optional peers (global npm installs)", async () => {
-    if (flagBool(args, "no-cli")) return ["skipped", "--no-cli"]
-    if (FROM_SOURCE) return ["skipped", "running from the repo checkout — the CLI and its peers are the repo's own"]
-    // Where each peer lives decides how it moves: the CLI's own prefix (~/.lecodes/peers, filled on
-    // first use) is re-installed by peerInstall — the renderer there tracks THIS CLI's version, not
-    // npm's latest, because compiler and headless host are one ABI set; a global install
-    // (`npm install -g`, the old way) moves through npm like before.
-    const rows: { name: string, installed: string | null, latest: string | null, where: "global" | "prefix" | null }[] = []
-    for (const [name, probe] of OPTIONAL_PEERS) {
-      const where = peerSource(name, probe)
-      const installed = peerVersion(name, probe)
-      const latest = !installed ? null
-        : where === "prefix" && name === "lecodes-renderer" ? pkg.version
-        : await npmLatest(name)
-      rows.push({ name, installed, latest, where })
-    }
-    rows.push({ name: "lecodes-cli", installed: pkg.version, latest: await npmLatest("lecodes-cli"), where: "global" })
-    if (rows.every((r) => r.latest === null)) return ["skipped", "npm unreachable"]
-    const behind = rows.filter((r) => r.installed && r.latest && semverNewer(r.latest, r.installed) > 0)
-    for (const r of rows) {
-      const state = !r.installed ? c.dim("not installed (optional — installed on first use)")
-        : !r.latest ? c.dim("(npm: unknown)")
-        : behind.includes(r) ? c.yellow("→ " + r.latest)
-        : c.dim("(up to date)")
-      log("  " + r.name.padEnd(18) + " " + (r.installed ?? "").padEnd(8) + " " + (r.where === "prefix" ? c.dim("peers ") : "") + state)
-    }
-    if (behind.length === 0) return "ok"
-    const prefixBehind = behind.filter((r) => r.where === "prefix")
-    const globalSpecs = behind.filter((r) => r.where !== "prefix").map((r) => r.name + "@latest")
-    if (flagBool(args, "check")) {
-      return ["updated", behind.length + " behind — run: lecodes update" + (globalSpecs.length ? "  (global: npm install -g " + globalSpecs.join(" ") + ")" : "")]
-    }
-    const done: string[] = []
-    if (prefixBehind.length) {
-      await installPeers(prefixBehind.map((r) => r.name), "lecodes update", { yes: true })
-      done.push(...prefixBehind.map((r) => r.name))
-    }
-    if (STANDALONE && globalSpecs.some((s) => s.startsWith("lecodes-cli@"))) {
-      note("this is the standalone build — the CLI updates by re-installing the release archive, not through npm; peers still go through npm")
-    }
-    const toInstall = STANDALONE ? globalSpecs.filter((s) => !s.startsWith("lecodes-cli@")) : globalSpecs
-    if (toInstall.length) {
-      log("  " + c.dim("$") + " npm install -g " + toInstall.join(" "))
-      const r = spawnSync("npm", ["install", "-g", ...toInstall], { stdio: "inherit", shell: true })
-      if (r.status !== 0) throw new CliError("npm install -g exited with " + (r.status ?? "a signal"))
-      done.push(...toInstall.map((s) => s.replace("@latest", "")))
-    }
-    if (done.length === 0) return ["skipped", "only the standalone CLI itself is behind — download the release"]
-    const cliToo = done.includes("lecodes-cli")
-    return ["updated", done.join(", ") + " → latest" + (cliToo ? " (the new CLI runs from your next command)" : "")]
-  })
-
-  // Summary — one line per step so a scrolled-away failure can't hide.
-  log(`\n${c.bold("Summary")}`)
-  const width = Math.max(...steps.map((s) => s.name.length))
-  for (const s of steps) {
-    const mark = s.outcome === "failed" ? c.red("✗") : s.outcome === "skipped" ? c.dim("–") : c.green("✓")
-    log(`  ${mark} ${s.name.padEnd(width)}  ${s.outcome === "failed" ? c.red(s.detail ?? "failed") : s.outcome === "skipped" ? c.dim(s.detail ?? "skipped") : s.detail ?? s.outcome}`)
-  }
-  if (steps.some((s) => s.outcome === "failed")) process.exitCode = 1
-}

package/src/util.ts

@@ -1,146 +0,0 @@
-import { createHash } from "node:crypto"
-import { createInterface } from "node:readline"
-import { sanitizeAssetName } from "lecodes-sdk/compile/assetName"
-
-/* Small dependency-free helpers shared across commands: colored logging, prompts, hashing,
- * posix-path normalization and a minimal argv parser. */
-
-const useColor = process.stdout.isTTY && process.env.NO_COLOR === undefined
-const paint = (code: string, s: string) => useColor ? `\x1b[${code}m${s}\x1b[0m` : s
-export const c = {
-  bold: (s: string) => paint("1", s),
-  dim: (s: string) => paint("2", s),
-  red: (s: string) => paint("31", s),
-  green: (s: string) => paint("32", s),
-  yellow: (s: string) => paint("33", s),
-  cyan: (s: string) => paint("36", s),
-}
-
-export const log = (msg = ""): void => { process.stdout.write(msg + "\n") }
-export const info = (msg: string) => log(msg)
-export const success = (msg: string) => log(c.green("✓ ") + msg)
-export const warn = (msg: string) => log(c.yellow("! ") + msg)
-
-// stderr variants — for commands that write a result (JS, data) to stdout, so diagnostics never
-// pollute the piped output.
-export const logErr = (msg = "") => process.stderr.write(msg + "\n")
-export const note = (msg: string) => logErr(c.dim(msg))
-export const warnErr = (msg: string) => logErr(c.yellow("! ") + msg)
-
-/** Keep a label short, dropping characters from the FRONT (paths matter most at the end). */
-const ellipsize = (s: string, max: number) => s.length <= max ? s : "…" + s.slice(s.length - max + 1)
-
-/** A single, in-place-updating progress line (TTY only; a no-op when piped). */
-export const progress = (done: number, total: number, label = "") => {
-  if (!process.stdout.isTTY) return
-  const pct = total > 0 ? Math.round((done / total) * 100) : 100
-  process.stdout.clearLine(0)
-  process.stdout.cursorTo(0)
-  process.stdout.write(`  ${c.cyan(`${pct}`.padStart(3) + "%")} ${c.dim(`(${done}/${total})`)} ${c.dim(ellipsize(label, 48))}`)
-}
-
-/** Finish a progress line with a newline so later output starts cleanly. */
-export const endProgress = () => { if (process.stdout.isTTY) process.stdout.write("\n") }
-
-/** A user-facing error: index.ts prints its message without a stack trace and exits non-zero. */
-export class CliError extends Error {
-  /** HTTP status, when the failure came from the API. Lets a caller tell "already gone" (404) from
-   *  "refused" (403) — deleting something the server no longer has is a success, not an error. */
-  status?: number
-  constructor(message: string, status?: number) {
-    super(message)
-    this.status = status
-  }
-}
-
-// Output targets that mean "discard" — so `-o /dev/null` (or Windows NUL) doesn't create a real file.
-const NULL_SINKS = new Set(["/dev/null", "nul", "//./nul"])
-/** True if an `--out` value is a null device, i.e. the output should be thrown away, not written. */
-export const isNullSink = (path: string): boolean =>
-  NULL_SINKS.has(path.trim().replace(/\\/g, "/").toLowerCase())
-
-export const sha256 = (data: string | Uint8Array): string =>
-  createHash("sha256").update(data).digest("hex")
-
-/** Normalize any path to a leading-slash, forward-slash, "." / ".." free key (e.g. "/a/b.ts").
- *  Each segment gets the platform's canonical spelling (sdk/compile/assetName) — macOS hands out
- *  decomposed names ("й" as и + U+0306) from readdir, which would otherwise key a file differently
- *  than the same name typed in an import or stored on the server. */
-export const toKey = (path: string): string => {
-  const parts = path.replace(/\\/g, "/").split("/").map(p => p.trim()).filter(p => p && p !== ".")
-  if (parts.some(p => p === "..")) throw new CliError(`Unsafe path: ${path}`)
-  const names = parts.map(p => sanitizeAssetName(p))
-  if (names.some(name => !name)) throw new CliError(`Wrong path: ${path}`)
-  return "/" + names.join("/")
-}
-
-export const prompt = (question: string, fallback?: string): Promise<string> =>
-  new Promise(resolve => {
-    const rl = createInterface({ input: process.stdin, output: process.stdout })
-    const suffix = fallback ? c.dim(` (${fallback})`) : ""
-    rl.question(`${question}${suffix}: `, answer => {
-      rl.close()
-      resolve(answer.trim() || fallback || "")
-    })
-  })
-
-/** Prompt without echoing the input (for passwords / token paste). */
-export const promptHidden = (question: string): Promise<string> =>
-  new Promise(resolve => {
-    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true })
-    rl.question(`${question}: `, answer => {
-      rl.close()
-      process.stdout.write("\n")
-      resolve(answer.trim())
-    })
-    // Mute everything written after the prompt line was emitted (the keystroke echoes).
-    ;(rl as unknown as { _writeToOutput: (s: string) => void })._writeToOutput = () => {}
-  })
-
-export const confirm = async (question: string, fallback = false): Promise<boolean> => {
-  const answer = (await prompt(`${question} ${fallback ? "[Y/n]" : "[y/N]"}`)).toLowerCase()
-  if (!answer) return fallback
-  return answer === "y" || answer === "yes"
-}
-
-export type Args = { _: string[], flags: Record<string, string | boolean> }
-
-/** Parse argv into positionals + flags. Supports `--key value`, `--key=value`, `--bool`, `-m msg`. */
-// `--look-at -0.15,1,2` / `--scale -1`: a token that starts with "-" followed by a digit (or ".5")
-// is a negative NUMBER (or a vector starting with one), not the next flag.
-const isNegativeNumber = (s: string): boolean => /^-(\d|\.\d)/.test(s)
-const isValue = (s: string): boolean => !s.startsWith("-") || isNegativeNumber(s)
-
-export const parseArgs = (argv: string[]): Args => {
-  const out: Args = { _: [], flags: {} }
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i]
-    if (arg.startsWith("--")) {
-      const eq = arg.indexOf("=")
-      if (eq >= 0) { out.flags[arg.slice(2, eq)] = arg.slice(eq + 1); continue }
-      const key = arg.slice(2)
-      const next = argv[i + 1]
-      if (next !== undefined && isValue(next)) { out.flags[key] = next; i++ }
-      else out.flags[key] = true
-    } else if (arg.startsWith("-") && arg.length > 1 && !isNegativeNumber(arg)) {
-      const key = arg.slice(1)
-      const next = argv[i + 1]
-      if (next !== undefined && isValue(next)) { out.flags[key] = next; i++ }
-      else out.flags[key] = true
-    } else {
-      out._.push(arg)
-    }
-  }
-  return out
-}
-
-export const flagStr = (args: Args, ...keys: string[]): string | undefined => {
-  for (const key of keys) {
-    const v = args.flags[key]
-    if (typeof v === "string") return v
-  }
-  return undefined
-}
-
-export const flagBool = (args: Args, ...keys: string[]): boolean =>
-  keys.some(key => args.flags[key] === true || args.flags[key] === "true")