lecodes-cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/commands/clone.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync5, readdirSync } from "node:fs";
@@ -21,6 +23,25 @@ var log = (msg = "") => process.stdout.write(msg + `
 `);
 var info = (msg) => log(msg);
 var success = (msg) => log(c.green("✓ ") + msg);
+var logErr = (msg = "") => process.stderr.write(msg + `
+`);
+var note = (msg) => logErr(c.dim(msg));
+var warnErr = (msg) => logErr(c.yellow("! ") + msg);
+var ellipsize = (s, max) => s.length <= max ? s : "…" + s.slice(s.length - max + 1);
+var progress = (done, total, 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))}`);
+};
+var endProgress = () => {
+  if (process.stdout.isTTY)
+    process.stdout.write(`
+`);
+};
+
 class CliError extends Error {
 }
 var sha256 = (data) => createHash("sha256").update(data).digest("hex");
@@ -38,16 +59,6 @@ var prompt = (question, fallback) => new Promise((resolve) => {
     resolve(answer.trim() || fallback || "");
   });
 });
-var promptHidden = (question) => new Promise((resolve) => {
-  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-  rl.question(`${question}: `, (answer) => {
-    rl.close();
-    process.stdout.write(`
-`);
-    resolve(answer.trim());
-  });
-  rl._writeToOutput = () => {};
-});
 var parseArgs = (argv) => {
   const out = { _: [], flags: {} };
   for (let i = 0;i < argv.length; i++) {
@@ -133,8 +144,6 @@ var apiRequest = async (apiUrl, path, opts = {}) => {
     throw new CliError(errorMessage(parsed, resp.status));
   return parsed;
 };
-var login = (apiUrl, login2, password) => apiRequest(apiUrl, "/account/login", { body: { login: login2, password } });
-var createAccessToken = (apiUrl, jwt, name) => apiRequest(apiUrl, "/account/tokens", { token: jwt, body: { name } });
 var getAccount = (apiUrl, token) => apiRequest(apiUrl, "/account", { token });
 var getProject = (apiUrl, token, uuid) => apiRequest(apiUrl, `/projects/${uuid}`, { token });
 var getCommits = (apiUrl, token, uuid) => apiRequest(apiUrl, `/projects/${uuid}/commits`, { token });
@@ -226,9 +235,11 @@ var buildPaths = (assets) => {
   }
   return pathById;
 };
-var materializeAssets = async (root, project, apiUrl, token) => {
+var materializeAssets = async (root, project, apiUrl, token, onProgress) => {
   const pathById = buildPaths(project.assets);
   const files = {};
+  const total = project.assets.filter((a) => a.type !== "folder").length;
+  let done = 0;
   for (const asset of project.assets) {
     const key = pathById.get(asset.id);
     const abs = absOf(root, key);
@@ -250,6 +261,7 @@ var materializeAssets = async (root, project, apiUrl, token) => {
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf(asset.type), sha };
+    onProgress?.(++done, total, key);
   }
   return files;
 };
@@ -322,8 +334,9 @@ var parseUuid = (input) => {
     throw new CliError("Usage: lecodes clone <project-uuid|url> [directory]");
   if (!input.includes("/"))
     return input;
-  const noQuery = input.split(/[?#]/)[0].replace(/\/+$/, "");
-  return noQuery.slice(noQuery.lastIndexOf("/") + 1);
+  const clean = input.split(/[?#]/)[0].replace(/\/+$/, "");
+  const match = clean.match(/\/(?:projects|view)\/([^/]+)/);
+  return match ? match[1] : clean.slice(clean.lastIndexOf("/") + 1);
 };
 var slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
 var clone = async (args) => {
@@ -331,7 +344,6 @@ var clone = async (args) => {
   const apiUrl = requireApiUrl(config);
   const token = requireToken(config);
   const uuid = parseUuid(args._[0]);
-  info(c.dim(`Fetching project ${uuid}…`));
   const project = await getProject(apiUrl, token, uuid);
   const dir = args._[1] ?? slug(project.name);
   const root = resolve(dir);
@@ -339,8 +351,9 @@ var clone = async (args) => {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
   mkdirSync5(root, { recursive: true });
-  info(c.dim(`Writing ${project.assets.filter((a) => a.type !== "folder").length} files…`));
-  const files = await materializeAssets(root, project, apiUrl, token);
+  info(c.dim(`Fetching project ${c.bold(project.name)}…`));
+  const files = await materializeAssets(root, project, apiUrl, token, progress);
+  endProgress();
   if (!flagBool(args, "no-types")) {
     info(c.dim("Fetching type definitions…"));
     await materializeTypes(root, apiUrl);
@@ -348,32 +361,106 @@ var clone = async (args) => {
   }
   const commits = await getCommits(apiUrl, token, uuid);
   writeManifest(root, { uuid, apiUrl, name: project.name, baseHeadId: commits.headId, files });
-  success(`Cloned ${c.bold(project.name)} into ${c.bold(dir)}/`);
+  success(`Cloned ${c.bold(project.name)} into ${c.bold(dir)}/ (${Object.keys(files).length} files)`);
   info(c.dim(`  cd ${dir} — edit, then \`lecodes push -m "your message"\``));
 };
 
-// src/commands/login.ts
+// src/browserAuth.ts
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import { hostname } from "node:os";
-var login2 = async (args) => {
-  const config = loadConfig();
-  const apiUrl = normalizeApiUrl(flagStr(args, "api") ?? await prompt("Server URL", config.apiUrl ?? DEFAULT_API));
-  let token = flagStr(args, "token");
-  if (!token) {
-    const email = flagStr(args, "email") ?? await prompt("Email");
-    const password = await promptHidden("Password");
-    info(c.dim("Authenticating…"));
-    const { accessToken } = await login(apiUrl, email, password);
-    const created = await createAccessToken(apiUrl, accessToken, `lecodes CLI (${hostname()})`);
-    token = created.token;
+var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
+<body style="font-family:system-ui,sans-serif;background:#0f1115;color:#e6e6e6;display:grid;place-items:center;height:100vh;margin:0">
+<div style="text-align:center;max-width:420px;padding:32px">
+<h1 style="font-size:20px;margin:0 0 8px">&#10003; Authorized</h1>
+<p style="color:#9aa0aa;margin:0;font-size:14px">You can close this tab and return to your terminal.</p></div>`;
+var errorHtml = (msg) => `<!doctype html><meta charset="utf-8"><title>lecodes</title>
+<body style="font-family:system-ui,sans-serif;background:#0f1115;color:#e6e6e6;display:grid;place-items:center;height:100vh;margin:0">
+<div style="text-align:center;max-width:420px;padding:32px">
+<h1 style="font-size:20px;margin:0 0 8px">Authorization failed</h1>
+<p style="color:#9aa0aa;margin:0;font-size:14px">${msg}</p></div>`;
+var openBrowser = (url) => {
+  let cmd;
+  let args;
+  if (process.platform === "win32") {
+    cmd = "rundll32";
+    args = ["url.dll,FileProtocolHandler", url];
+  } else if (process.platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+  } catch {}
+};
+var browserLogin = async (webBase, timeoutMs = 5 * 60 * 1000, open = openBrowser) => {
+  const state = randomBytes(16).toString("hex");
+  let resolve2;
+  let reject;
+  const tokenPromise = new Promise((res, rej) => {
+    resolve2 = res;
+    reject = rej;
+  });
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== "/") {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const token = url.searchParams.get("token");
+    if (!token || url.searchParams.get("state") !== state) {
+      res.writeHead(400, { "content-type": "text/html" });
+      res.end(errorHtml("Invalid or expired authorization."));
+      return;
+    }
+    res.writeHead(200, { "content-type": "text/html" });
+    res.end(SUCCESS_HTML);
+    resolve2(token);
+  });
+  await new Promise((res, rej) => {
+    server.once("error", rej);
+    server.listen(0, "127.0.0.1", res);
+  });
+  const port = server.address().port;
+  const timer = setTimeout(() => reject(new CliError("Timed out waiting for browser authorization.")), timeoutMs);
+  const authUrl = `${webBase}/app/cli-auth?port=${port}&state=${state}&name=${encodeURIComponent(hostname())}`;
+  info("Opening your browser to authorize the CLI…");
+  log(c.dim("  " + authUrl));
+  log(c.dim("  (waiting — finish in the browser, or press Ctrl+C to cancel)"));
+  open(authUrl);
+  try {
+    return await tokenPromise;
+  } finally {
+    clearTimeout(timer);
+    server.close();
   }
+};
+
+// src/commands/login.ts
+var login = async (args) => {
+  const config = loadConfig();
+  const apiUrl = normalizeApiUrl(flagStr(args, "api") ?? config.apiUrl ?? DEFAULT_API);
+  const webBase = normalizeApiUrl(flagStr(args, "web") ?? apiUrl);
+  const token = flagStr(args, "token") ?? await browserLogin(webBase);
   const account = await getAccount(apiUrl, token);
   saveConfig({ apiUrl, token });
   success(`Logged in as ${c.bold(account.email)} on ${apiUrl}`);
 };
 
-// src/commands/pull.ts
-import { existsSync as existsSync3, rmSync } from "node:fs";
-import { join as join6 } from "node:path";
+// src/commands/preview.ts
+import { writeFileSync as writeFileSync5 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+
+// src/compile/collect.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { basename } from "node:path";
 
 // src/localFiles.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
@@ -462,7 +549,369 @@ var diffLocal = (manifest, scan) => {
 };
 var hasChanges = (diff) => diff.added.length + diff.modified.length + diff.deleted.length > 0;
 
+// src/compile/collect.ts
+var collectEntries = (root, manifest, project) => {
+  const pathById = buildPaths(project.assets);
+  const serverByPath = new Map;
+  for (const asset of project.assets) {
+    if (asset.type === "folder")
+      continue;
+    serverByPath.set(pathById.get(asset.id), { fileSrc: asset.file?.src ?? undefined, shaders: asset.shaders ?? [] });
+  }
+  const entries = [];
+  const warnings = [];
+  for (const file of scanLocal(root).files) {
+    const type = manifest.files[file.path]?.type ?? classifyKind(basename(file.path));
+    if (type === "resource") {
+      const src = serverByPath.get(file.path)?.fileSrc;
+      if (!src)
+        warnings.push(`No server URL for ${file.path} — push it so its URL resolves.`);
+      entries.push({ path: file.path, type, fileSrc: src });
+    } else if (type === "shader") {
+      const shaders = serverByPath.get(file.path)?.shaders;
+      if (!shaders?.length)
+        warnings.push(`No compiled shader for ${file.path} — push it to compile the shader.`);
+      entries.push({ path: file.path, type, shaders });
+    } else {
+      entries.push({ path: file.path, type, text: readFileSync4(file.absPath, "utf8") });
+    }
+  }
+  return { entries, warnings };
+};
+
+// src/compile/bundler.ts
+import * as esbuild from "esbuild";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname3, join as join6 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/compile/assetMacro.ts
+var ASSET_RE = /\basset\(\s*(["'])((?:[^"'\\]|\\.)*)\1\s*\)/g;
+var hasAssetMacro = (src) => src.includes("asset(");
+var desugarAssetMacros = (src, filePath) => {
+  const byPath = new Map;
+  let i = 0;
+  const out = src.replace(ASSET_RE, (_match, _quote, path) => {
+    let name = byPath.get(path);
+    if (!name) {
+      name = `__asset_${i++}`;
+      byPath.set(path, name);
+    }
+    return name;
+  });
+  if (/\basset\(/.test(out)) {
+    throw new Error(`asset() expects a string literal, found a dynamic argument in: ${filePath}`);
+  }
+  if (byPath.size === 0)
+    return src;
+  const header = [...byPath].map(([path, name]) => `import ${name} from ${JSON.stringify(path)};`).join(`
+`);
+  return header + `
+` + out;
+};
+
+// src/compile/bundler.ts
+var GL_MATRIX_HEADER = `
+import * as glMatrix from "gl-matrix/common";
+import * as mat2 from "gl-matrix/mat2";
+import * as mat2d from "gl-matrix/mat2d";
+import * as mat3 from "gl-matrix/mat3";
+import * as mat4 from "gl-matrix/mat4";
+import * as quat from "gl-matrix/quat";
+import * as quat2 from "gl-matrix/quat2";
+import * as vec2 from "gl-matrix/vec2";
+import * as vec3 from "gl-matrix/vec3";
+import * as vec4 from "gl-matrix/vec4";
+`;
+var resolveRuntime = () => {
+  const here = dirname3(fileURLToPath(import.meta.url));
+  const vendored = join6(here, "..", "runtime");
+  if (existsSync3(join6(vendored, "worker", "creator.js"))) {
+    const w = join6(vendored, "worker");
+    return {
+      alias: {
+        creator: join6(w, "creator.js"),
+        ui: join6(w, "ui.js"),
+        animate: join6(w, "animate.js"),
+        utils: join6(w, "utils.js"),
+        "gl-matrix": join6(vendored, "gl-matrix")
+      },
+      inject: [join6(w, "globals.js")]
+    };
+  }
+  const repoRoot = join6(here, "..", "..", "..", "..");
+  const ws = join6(repoRoot, "packages", "worker", "src");
+  if (existsSync3(join6(ws, "index.ts"))) {
+    return {
+      alias: {
+        creator: join6(ws, "index.ts"),
+        ui: join6(ws, "ui.ts"),
+        animate: join6(ws, "animate.ts"),
+        utils: join6(ws, "utils.ts"),
+        "gl-matrix": join6(repoRoot, "packages", "backend", "src", "assets", "dependencies", "gl-matrix")
+      },
+      inject: [join6(ws, "globals.ts")]
+    };
+  }
+  throw new CliError("Could not locate the compile runtime — try reinstalling lecodes-cli.");
+};
+function normalize(path) {
+  const parts = [];
+  for (const part of path.split("/")) {
+    if (!part || part === ".")
+      continue;
+    if (part === "..")
+      parts.pop();
+    else
+      parts.push(part);
+  }
+  return "/" + parts.join("/");
+}
+function dirOf(path) {
+  const i = path.lastIndexOf("/");
+  return i <= 0 ? "/" : path.slice(0, i);
+}
+var hasExtension = (path) => /\.[a-zA-Z0-9]+$/.test(path);
+function resolveBase(importer, specifier) {
+  if (specifier.startsWith("/"))
+    return normalize(specifier);
+  if (specifier.startsWith("./") || specifier.startsWith("../"))
+    return normalize(dirOf(importer) + "/" + specifier);
+  throw new Error(`Bare import is not allowed here: ${specifier}`);
+}
+function resolveWithExtensions(files, importer, specifier) {
+  const base = resolveBase(importer, specifier);
+  if (hasExtension(base)) {
+    if (files.has(base))
+      return base;
+    throw new Error(`Module not found: ${base}`);
+  }
+  for (const candidate of [base, `${base}.ts`, `${base}.js`]) {
+    if (files.has(candidate))
+      return candidate;
+  }
+  throw new Error(`Module not found: ${specifier} from ${importer}`);
+}
+var getLoader = (path) => path.endsWith(".ts") ? "ts" : "js";
+async function buildInMemory(entrypoint, inputFiles, format = "esm") {
+  const runtime = resolveRuntime();
+  const files = new Map(Object.entries(inputFiles).map(([k, v]) => [normalize(k), v]));
+  const entry = normalize(entrypoint);
+  if (!files.has(entry))
+    throw new CliError(`Entrypoint not found: ${entry}`);
+  const plugin = {
+    name: "memfs",
+    setup(build2) {
+      build2.onResolve({ filter: /^entry$/ }, () => ({ path: entry, namespace: "mem" }));
+      build2.onResolve({ filter: /.*/, namespace: "mem" }, (args) => {
+        const isRelative = args.path.startsWith("./") || args.path.startsWith("../");
+        const isAbsolute = args.path.startsWith("/");
+        if (!isRelative && !isAbsolute)
+          return null;
+        try {
+          return { path: resolveWithExtensions(files, args.importer || entry, args.path), namespace: "mem" };
+        } catch (error) {
+          return { errors: [{ text: error instanceof Error ? error.message : String(error) }] };
+        }
+      });
+      build2.onLoad({ filter: /.*/, namespace: "mem" }, (args) => {
+        const contents = files.get(args.path);
+        if (contents == null)
+          return { errors: [{ text: `Module not found: ${args.path}` }] };
+        const finalContents = /\.[tj]sx?$/.test(args.path) && hasAssetMacro(contents) ? desugarAssetMacros(contents, args.path) : contents;
+        return { contents: finalContents, loader: getLoader(args.path), resolveDir: dirOf(args.path) };
+      });
+    }
+  };
+  const result = await esbuild.build({
+    stdin: { contents: `import "entry";`, loader: "js", sourcefile: "bootstrap.js" },
+    alias: runtime.alias,
+    define: { RAD2DEG: "57.29577951308232", DEG2RAD: "0.017453292519943295" },
+    inject: runtime.inject,
+    bundle: true,
+    write: false,
+    format,
+    platform: "browser",
+    plugins: [plugin],
+    charset: "utf8"
+  });
+  const output = result.outputFiles?.[0];
+  if (!output)
+    throw new CliError("Compilation produced no output");
+  return output.text;
+}
+
+// src/compile/projectCompile.ts
+var buildHeader = (name, code) => {
+  let header = `// name: ${name.slice(0, 20)}
+`;
+  header += `// last-updated: ${new Date().toISOString()}
+`;
+  const localAssets = new Set;
+  for (const m of code.matchAll(/_creatorUtils\.fetchLocal\((.+?)\)/g)) {
+    localAssets.add(m[1].replaceAll(/['"]/g, "").trim());
+  }
+  if (/_creator\.createGlb/.test(code))
+    localAssets.add("uberarchive");
+  if (/_creator\.captureImage/.test(code))
+    localAssets.add("capture");
+  if (localAssets.size > 0)
+    header += `// preload: ${[...localAssets].join(";")}
+`;
+  if (!code.includes("_creator.createScene") && !code.includes("_creator.createEntity"))
+    header += `// gl: disable
+`;
+  else if (code.includes("_creator.createEngine"))
+    header += `// gl: defer
+`;
+  if (code.includes("_creator.createARController"))
+    header += "// ar: enable";
+  header += `
+`;
+  return header;
+};
+var detectEntry = (entries) => {
+  let entry = "";
+  let max = -1;
+  for (const e of entries) {
+    const ext2 = e.path.split(".").at(-1)?.toLowerCase();
+    if (e.type === "text" && e.text !== undefined && !e.text.includes("export") && (ext2 === "ts" || ext2 === "js")) {
+      if (e.text.length > max) {
+        entry = e.path;
+        max = e.text.length;
+      }
+    }
+  }
+  return entry;
+};
+var compileProject = async (opts) => {
+  const entry = opts.entryOverride ?? detectEntry(opts.entries);
+  if (!entry) {
+    throw new CliError("Couldn't find an entrypoint (a top-level .ts/.js file with no `export`). Pass --entry <path>.");
+  }
+  const files = {};
+  for (const e of opts.entries) {
+    if (e.type === "resource") {
+      files[e.path] = `export default "${opts.publicUrl}${e.fileSrc ?? ""}"`;
+    } else if (e.type === "shader") {
+      const shaders = e.shaders ?? [];
+      if (shaders.length > 2) {
+        files[e.path] = `export default \`${opts.publicUrl}${shaders[0].src.replace("_opengl", "_${_creator.subBackend ?? _creator.backend}")}\``;
+      } else if (shaders.length > 0) {
+        files[e.path] = `export default \`${opts.publicUrl}${shaders[0].src.replace("_opengl", "_${_creator.backend}")}\``;
+      } else {
+        files[e.path] = `export default ""`;
+      }
+    } else if (e.path.toLowerCase().endsWith(".svg")) {
+      files[e.path] = `export default SvgSource(\`${e.text ?? ""}\`)`;
+    } else {
+      files[e.path] = GL_MATRIX_HEADER + (e.text ?? "");
+    }
+  }
+  const code = await buildInMemory(entry, files, opts.format ?? "esm");
+  return opts.header === false ? code : buildHeader(opts.name, code) + code;
+};
+
+// src/commands/preview.ts
+var preview = async (args) => {
+  const root = findProjectRoot(process.cwd());
+  const manifest = readManifest(root);
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  note("Resolving project assets…");
+  const project = await getProject(apiUrl, token, manifest.uuid);
+  const { entries, warnings } = collectEntries(root, manifest, project);
+  note("Compiling…");
+  const js = await compileProject({
+    entries,
+    name: manifest.name,
+    publicUrl: flagStr(args, "public-url") ?? apiUrl,
+    entryOverride: flagStr(args, "entry"),
+    header: !flagBool(args, "no-header")
+  });
+  for (const w of warnings)
+    warnErr(w);
+  const out = flagStr(args, "o", "out");
+  if (out) {
+    writeFileSync5(resolve2(out), js);
+    note(`Wrote ${out} (${js.length} bytes)`);
+  } else {
+    process.stdout.write(js);
+    if (!js.endsWith(`
+`))
+      process.stdout.write(`
+`);
+  }
+};
+
+// src/commands/render.ts
+import { writeFileSync as writeFileSync6 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+var render = async (args) => {
+  const root = findProjectRoot(process.cwd());
+  const manifest = readManifest(root);
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  note("Resolving project assets…");
+  const project = await getProject(apiUrl, token, manifest.uuid);
+  const { entries, warnings } = collectEntries(root, manifest, project);
+  note("Compiling…");
+  const js = await compileProject({
+    entries,
+    name: manifest.name,
+    publicUrl: flagStr(args, "public-url") ?? apiUrl,
+    entryOverride: flagStr(args, "entry"),
+    header: false,
+    format: "iife"
+  });
+  if (js.includes("_creator.createScene") || js.includes("_creator.createEntity")) {
+    warnings.push("This looks like a 3D/GL project — only the UI layer is rendered.");
+  }
+  let renderer;
+  try {
+    renderer = await import("lecodes-render");
+  } catch {
+    throw new CliError("The renderer isn't installed. Run:  npm i -D lecodes-render");
+  }
+  const width = Number(flagStr(args, "width")) || 390;
+  const height = Number(flagStr(args, "height")) || 844;
+  const pngFlag = flagStr(args, "png") ?? (flagBool(args, "png") ? "screenshot.png" : undefined);
+  if (pngFlag !== undefined) {
+    note("Rendering PNG…");
+    const { png, warnings: pngWarnings } = await renderer.renderToPng(js, {
+      width,
+      height,
+      scale: Number(flagStr(args, "scale")) || 2
+    });
+    const pngPath = resolve3(pngFlag);
+    writeFileSync6(pngPath, png);
+    for (const w of [...warnings, ...pngWarnings])
+      warnErr(w);
+    note(`Wrote ${pngFlag} (${png.length} bytes, ${width}x${height})`);
+    return;
+  }
+  note("Rendering…");
+  const result = await renderer.renderToJson(js, { width, height });
+  for (const w of [...warnings, ...result.warnings])
+    warnErr(w);
+  const out = flagStr(args, "o", "out");
+  if (out) {
+    writeFileSync6(resolve3(out), result.text);
+    note(`Wrote ${out} (${result.text.length} bytes)`);
+  } else {
+    process.stdout.write(result.text);
+    if (!result.text.endsWith(`
+`))
+      process.stdout.write(`
+`);
+  }
+};
+
 // src/commands/pull.ts
+import { existsSync as existsSync4, rmSync } from "node:fs";
+import { join as join7 } from "node:path";
 var pull = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -477,12 +926,13 @@ var pull = async (args) => {
   const remotePaths = new Set([...buildPaths(project.assets).entries()].filter(([id]) => project.assets.find((a) => a.id === id)?.type !== "folder").map(([, path]) => path));
   for (const path of Object.keys(manifest.files)) {
     if (!remotePaths.has(path)) {
-      const abs = join6(root, ...path.replace(/^\//, "").split("/"));
-      if (existsSync3(abs))
+      const abs = join7(root, ...path.replace(/^\//, "").split("/"));
+      if (existsSync4(abs))
         rmSync(abs);
     }
   }
-  const files = await materializeAssets(root, project, apiUrl, token);
+  const files = await materializeAssets(root, project, apiUrl, token, progress);
+  endProgress();
   if (!flagBool(args, "no-types")) {
     await materializeTypes(root, apiUrl);
     writeTsconfig(root);
@@ -493,8 +943,8 @@ var pull = async (args) => {
 };
 
 // src/commands/push.ts
-import { basename } from "node:path";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { basename as basename2 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -519,14 +969,14 @@ var push = async (args) => {
   let uploaded = 0;
   for (const file of scan.files) {
     const source = sourceFor(file.path);
-    const kind = source?.type ?? classifyKind(basename(file.path));
+    const kind = source?.type ?? classifyKind(basename2(file.path));
     const entry = { path: file.path, type: kind };
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync4(file.absPath, "utf8");
+      entry.text = readFileSync5(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename(file.path), readFileSync4(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename2(file.path), readFileSync5(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -586,9 +1036,10 @@ var HELP = `${c.bold("lecodes")} — clone, edit and push LeCodes projects from
 ${c.bold("Usage:")} lecodes <command> [options]
 
 ${c.bold("Commands:")}
-  login                         Store a personal access token (prompts email/password)
-                                  --token <pat>   use an existing token instead
-                                  --api <url>     set the server URL
+  login                         Authorize in the browser and store an access token
+                                  --token <pat>   store a token from the web UI instead
+                                  --api <url>     API origin (default https://le.codes)
+                                  --web <url>     app origin for the browser flow
   clone <uuid|url> [dir]        Download a project's files + types into a new folder
                                   --no-types      skip the .d.ts / tsconfig generation
   status                        Show local changes vs the last sync
@@ -597,9 +1048,22 @@ ${c.bold("Commands:")}
   push                          Push local changes as one new checkpoint
                                   -m, --message   checkpoint message
                                   --force         push even if the server moved on
+  preview                       Compile the local project to JS (prints to stdout)
+                                  -o, --out <file>   write to a file instead of stdout
+                                  --entry <path>     override the entrypoint
+                                  --no-header        omit the metadata header
+                                  --public-url <url> asset URL prefix (default: the API origin)
+  render                        Render the local UI project to a semantic JSON description
+                                  (needs the optional 'lecodes-render' package; UI projects only)
+                                  -o, --out <file>   write JSON to a file instead of stdout
+                                  --png [file]       rasterize a PNG (default screenshot.png;
+                                                       needs @napi-rs/canvas)
+                                  --scale <n>        PNG device-pixel scale (default 2)
+                                  --width/--height   viewport size (default 390x844)
+                                  --entry <path>     override the entrypoint
 
 Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
-var commands = { login: login2, clone, status, pull, push };
+var commands = { login, clone, status, pull, push, preview, render };
 var main = async () => {
   const argv = process.argv.slice(2);
   const command = argv[0];