lecodes-cli 2.4.1 → 2.4.3

package/src/commands/init/index.ts

@@ -1,195 +1,195 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs"
-import { basename, dirname, join, resolve } from "node:path"
-import { LECODES_DIR } from "../../project/manifest"
-import { materializeTypesLocal, writeTsconfig } from "../../project/types"
-import { DEFAULT_IGNORE_FILE, ensureGitignore } from "../../project/ignore"
-import { appClaudeMd, CLAUDE_SETTINGS, STARTER_FLOW } from "./templates"
-import { bool, c, defineCommand, log, note, success, warnErr } from "../../cli"
-
-/*
- * `lecodes init [dir]` — scaffold a brand-new LOCAL project: no account, no login, no server.
- *
- * Writes a starter entry, a CLAUDE.md (the headless render/test workflow for AI assistants) with
- * a passing starter flow test, the SDK's import-free type surface + a tsconfig (so VS Code gives
- * full IntelliSense offline), and a `.lecodesignore`. The result runs immediately with `lecodes dev`
- * (hot reload on a device) and compiles with `lecodes compile -o app.js` (a self-contained bundle
- * for LeCodes Desktop). It's the offline counterpart to `lecodes create`, which makes a project on
- * the server; a local project needs no manifest — `dev`/`compile` compile straight from the tree.
- *
- * Idempotent: existing files are kept (never clobbered), so it's safe to re-run or run in a folder
- * that already has content. Only the generated tsconfig + `.lecodes/types/` are rewritten each run.
- */
-
-const STARTER = `// Welcome to LeCodes — the whole SDK is available as globals, no imports needed.
-// Run it live on a device with \`lecodes dev\`, or bundle it with \`lecodes compile -o app.js\`.
-
-let count = 0
-
-const counter = UIText("Taps: 0").style({ color: "#9fb0d0", fontSize: 22, marginTop: 18 })
-
-const button = UIButton(UIText("Tap me").style({ color: "#ffffff", fontSize: 22 }))
-  .style({
-    backgroundColor: "#4f7cff",
-    borderRadius: 14,
-    paddingVertical: 16,
-    paddingHorizontal: 40,
-    marginTop: 24,
-    alignItems: "center",
-    justifyContent: "center",
-    $hovered: { backgroundColor: "#6b91ff" }, // the mouse over it (desktop); $pressed is the press
-  })
-  .named("tap") // names make elements targetable in tests/*.flow.json (see CLAUDE.md)
-  .onClick(() => {
-    count++
-    counter.text = "Taps: " + count
-  })
-
-const screen = UIScreen(
-  UIColumn(UIText("Hello, LeCodes").style({ color: "#ffffff", fontSize: 32 }), button, counter)
-    .style({ backgroundColor: "#2b3550", borderRadius: 24, padding: 40, alignItems: "center" }),
-)
-  .style({ backgroundColor: "#1e2230", alignItems: "center", justifyContent: "center", padding: 40 })
-  .named("home") // the screen root's name is what tests' \`expect: { screen: … }\` reads
-
-screen.open()
-`
-
-/** `--desktop`: declare the desktop target up front. Window sizes are logical units (the host
- *  scales for HiDPI); `dev --desktop` / `desktop run` / `render --desktop` all read this, and a
- *  desktop-only app.json makes headless render/test default to the window size too. */
-const appJsonDesktop = (name: string) => JSON.stringify({
-  name,
-  desktop: {
-    window: { width: 1280, height: 800, minWidth: 640, minHeight: 480 },
-  },
-}, null, 2) + "\n"
-
-const readmeTemplate = (name: string) => `# ${name}
-
-A LeCodes app. The whole SDK is available as globals (\`UIScreen\`, \`UIText\`, \`Scene2D\`, …) —
-no imports needed. \`main.ts\` is the entry point.
-
-## Run it
-
-\`\`\`
-lecodes dev                  # live on your phone: scan the QR with the LeCodes app, hot reload
-lecodes compile -o app.js    # bundle to a single self-contained JS file
-\`\`\`
-
-## Test it (no device needed)
-
-\`\`\`
-lecodes render --png shot.png    # headless screenshot of the running app
-lecodes test                     # run tests/*.flow.json — the starter ships with a passing one
-\`\`\`
-
-Scenario format + conventions: see [CLAUDE.md](./CLAUDE.md) (written for AI assistants, useful
-for humans too).
-
-## Put it on the platform
-
-This project is local-only. To give it a home on le.codes (web editor, sharing, OTA updates):
-
-\`\`\`
-lecodes login                    # once per machine
-lecodes link                     # create a project from this folder and connect it
-lecodes push -m "initial"        # upload it as the first checkpoint (--publish to go live)
-\`\`\`
-
-Already made the project in the web editor? \`lecodes link --project <uuid>\` adopts it — it
-shows what your next push would change there before connecting anything.
-
-## Go native
-
-\`\`\`
-lecodes app init ios         # generate a native Xcode shell in ios/
-lecodes app sync             # embed the compiled bundle + plugins into it
-lecodes app open             # open it in Xcode, build & run
-\`\`\`
-
-## Layout
-
-- \`main.ts\` — the app's entry point. Add more .ts files freely and import them from
-  \`main.ts\`; a file named \`main.ts\` is always the entry.
-- \`tests/\` — headless flow tests (\`lecodes test\`); failing steps dump the frame to
-  \`tests/.artifacts/\`
-- \`CLAUDE.md\` — guidance for AI assistants (the headless feedback loop + testability conventions)
-- \`assets/\` — images/fonts the app references (created on demand)
-- \`tsconfig.json\` + \`.lecodes/types/\` — generated IDE types (rewritten by the CLI; don't edit).
-  They come from the SDK bundled in the CLI; \`lecodes update\` refreshes them from the platform.
-- \`.lecodes/\` is gitignored — per-checkout state (those types + \`manifest.json\`, this machine's
-  sync cursor once linked). After a fresh git clone: \`lecodes update\`, then
-  \`lecodes link --project <uuid>\` to re-attach.
-- \`.lecodesignore\` — files a future \`lecodes push\` would skip
-
-Full command list: \`lecodes --help\`.
-`
-
-export default defineCommand({
-  name: "init",
-  summary: "Scaffold a new LOCAL project (no login, no server)",
-  usage: "[dir]",
-  description: "Writes a starter main.ts, a CLAUDE.md + a passing flow test (the headless render / test loop), the IDE types + tsconfig, and a .lecodesignore. Run it with `lecodes dev` or `lecodes compile`. Idempotent: existing files are kept.",
-  flags: { desktop: bool("also write an app.json declaring the desktop target (window size; `dev --desktop`, `desktop run` and headless render / test pick it up)") },
-  examples: ["lecodes init myapp", "lecodes init --desktop"],
-  run: ({ args, flags }) => init(args[0], flags.desktop),
-})
-
-const init = (dir: string | undefined, forDesktop: boolean): void => {
-  const dirArg = (dir ?? ".").replace(/[/\\]+$/, "") || "."
-  const root = resolve(dirArg)
-  const name = basename(root)
-
-  mkdirSync(root, { recursive: true })
-
-  let created = 0
-  const write = (rel: string, content: string) => {
-    const abs = join(root, rel)
-    if (existsSync(abs)) { note(`kept      ${rel}`); return }
-    mkdirSync(dirname(abs), { recursive: true })
-    writeFileSync(abs, content)
-    log(`${c.green("created")}   ${rel}`)
-    created++
-  }
-
-  // Starter entry — a root file named main.ts is always the detected entrypoint.
-  write("main.ts", STARTER)
-  write("README.md", readmeTemplate(name))
-  // --desktop: an app.json declaring the desktop target (window config in logical units).
-  if (forDesktop) write("app.json", appJsonDesktop(name))
-  // AI-assistant guidance + a passing flow test: the headless loop is discoverable from day one.
-  write("CLAUDE.md", appClaudeMd(name))
-  write(".claude/settings.json", CLAUDE_SETTINGS)
-  write("tests/counter.flow.json", STARTER_FLOW)
-  // Keep local render/preview outputs (screenshot.png, shots/) out of any future push.
-  write(".lecodesignore", DEFAULT_IGNORE_FILE)
-  // .lecodes/ is per-checkout state (generated types + the push cursor) — keep it out of git.
-  const gi = ensureGitignore(root)
-  if (gi === "created") { log(`${c.green("created")}   .gitignore`); created++ }
-  else if (gi === "updated") log(`${c.green("updated")}   .gitignore  ${c.dim("(+ .lecodes/)")}`)
-  else note("kept      .gitignore")
-
-  // IDE types: the SDK's import-free global surface + a tsconfig, so VS Code resolves UIScreen,
-  // Scene2D, setLoop, … with no server. Regenerated every run to pick up CLI upgrades.
-  const wroteTypes = materializeTypesLocal(root)
-  writeTsconfig(root)
-  log(`${c.green("written")}   tsconfig.json${wroteTypes ? ` + ${LECODES_DIR}/types/` : ""}  (IDE types)`)
-  if (!wroteTypes) {
-    warnErr("Bundled SDK types not found — tsconfig written, but globals may show unresolved until the CLI is rebuilt with vendored types.")
-  }
-
-  log("")
-  success(created
-    ? `Local project ${c.bold(name)} ready${dirArg === "." ? "" : ` in ${c.bold(dirArg)}/`}.`
-    : `Project ${c.bold(name)} already initialized.`)
-  const cd = dirArg === "." ? "" : `cd ${dirArg} && `
-  if (forDesktop) {
-    log(`  ${c.bold(cd + "lecodes dev --desktop")}      run it in a desktop window with hot reload`)
-    log(`  ${c.bold(cd + "lecodes test")}               run the flow tests headless (desktop-sized)`)
-    log(`  ${c.bold(cd + "lecodes desktop run")}        open the compiled app in the desktop host`)
-  } else {
-    log(`  ${c.bold(cd + "lecodes dev")}                run it on a device with hot reload`)
-    log(`  ${c.bold(cd + "lecodes test")}               run the flow tests headless (no device)`)
-    log(`  ${c.bold(cd + "lecodes compile -o app.js")}  bundle it for LeCodes Desktop`)
-  }
-}
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { basename, dirname, join, resolve } from "node:path"
+import { LECODES_DIR } from "../../project/manifest"
+import { materializeTypesLocal, writeTsconfig } from "../../project/types"
+import { DEFAULT_IGNORE_FILE, ensureGitignore } from "../../project/ignore"
+import { appClaudeMd, CLAUDE_SETTINGS, STARTER_FLOW } from "./templates"
+import { bool, c, defineCommand, log, note, success, warnErr } from "../../cli"
+
+/*
+ * `lecodes init [dir]` — scaffold a brand-new LOCAL project: no account, no login, no server.
+ *
+ * Writes a starter entry, a CLAUDE.md (the headless render/test workflow for AI assistants) with
+ * a passing starter flow test, the SDK's import-free type surface + a tsconfig (so VS Code gives
+ * full IntelliSense offline), and a `.lecodesignore`. The result runs immediately with `lecodes dev`
+ * (hot reload on a device) and compiles with `lecodes compile -o app.js` (a self-contained bundle
+ * for LeCodes Desktop). It's the offline counterpart to `lecodes create`, which makes a project on
+ * the server; a local project needs no manifest — `dev`/`compile` compile straight from the tree.
+ *
+ * Idempotent: existing files are kept (never clobbered), so it's safe to re-run or run in a folder
+ * that already has content. Only the generated tsconfig + `.lecodes/types/` are rewritten each run.
+ */
+
+const STARTER = `// Welcome to LeCodes — the whole SDK is available as globals, no imports needed.
+// Run it live on a device with \`lecodes dev\`, or bundle it with \`lecodes compile -o app.js\`.
+
+let count = 0
+
+const counter = UIText("Taps: 0").style({ color: "#9fb0d0", fontSize: 22, marginTop: 18 })
+
+const button = UIButton(UIText("Tap me").style({ color: "#ffffff", fontSize: 22 }))
+  .style({
+    backgroundColor: "#4f7cff",
+    borderRadius: 14,
+    paddingVertical: 16,
+    paddingHorizontal: 40,
+    marginTop: 24,
+    alignItems: "center",
+    justifyContent: "center",
+    $hovered: { backgroundColor: "#6b91ff" }, // the mouse over it (desktop); $pressed is the press
+  })
+  .named("tap") // names make elements targetable in tests/*.flow.json (see CLAUDE.md)
+  .onClick(() => {
+    count++
+    counter.text = "Taps: " + count
+  })
+
+const screen = UIScreen(
+  UIColumn(UIText("Hello, LeCodes").style({ color: "#ffffff", fontSize: 32 }), button, counter)
+    .style({ backgroundColor: "#2b3550", borderRadius: 24, padding: 40, alignItems: "center" }),
+)
+  .style({ backgroundColor: "#1e2230", alignItems: "center", justifyContent: "center", padding: 40 })
+  .named("home") // the screen root's name is what tests' \`expect: { screen: … }\` reads
+
+screen.open()
+`
+
+/** `--desktop`: declare the desktop target up front. Window sizes are logical units (the host
+ *  scales for HiDPI); `dev --desktop` / `desktop run` / `render --desktop` all read this, and a
+ *  desktop-only app.json makes headless render/test default to the window size too. */
+const appJsonDesktop = (name: string) => JSON.stringify({
+  name,
+  desktop: {
+    window: { width: 1280, height: 800, minWidth: 640, minHeight: 480 },
+  },
+}, null, 2) + "\n"
+
+const readmeTemplate = (name: string) => `# ${name}
+
+A LeCodes app. The whole SDK is available as globals (\`UIScreen\`, \`UIText\`, \`Scene2D\`, …) —
+no imports needed. \`main.ts\` is the entry point.
+
+## Run it
+
+\`\`\`
+lecodes dev                  # live on your phone: scan the QR with the LeCodes app, hot reload
+lecodes compile -o app.js    # bundle to a single self-contained JS file
+\`\`\`
+
+## Test it (no device needed)
+
+\`\`\`
+lecodes render --png shot.png    # headless screenshot of the running app
+lecodes test                     # run tests/*.flow.json — the starter ships with a passing one
+\`\`\`
+
+Scenario format + conventions: see [CLAUDE.md](./CLAUDE.md) (written for AI assistants, useful
+for humans too).
+
+## Put it on the platform
+
+This project is local-only. To give it a home on le.codes (web editor, sharing, OTA updates):
+
+\`\`\`
+lecodes login                    # once per machine
+lecodes link                     # create a project from this folder and connect it
+lecodes push -m "initial"        # upload it as the first checkpoint (--publish to go live)
+\`\`\`
+
+Already made the project in the web editor? \`lecodes link --project <uuid>\` adopts it — it
+shows what your next push would change there before connecting anything.
+
+## Go native
+
+\`\`\`
+lecodes app init ios         # generate a native Xcode shell in ios/
+lecodes app sync             # embed the compiled bundle + plugins into it
+lecodes app open             # open it in Xcode, build & run
+\`\`\`
+
+## Layout
+
+- \`main.ts\` — the app's entry point. Add more .ts files freely and import them from
+  \`main.ts\`; a file named \`main.ts\` is always the entry.
+- \`tests/\` — headless flow tests (\`lecodes test\`); failing steps dump the frame to
+  \`tests/.artifacts/\`
+- \`CLAUDE.md\` — guidance for AI assistants (the headless feedback loop + testability conventions)
+- \`assets/\` — images/fonts the app references (created on demand)
+- \`tsconfig.json\` + \`.lecodes/types/\` — generated IDE types (rewritten by the CLI; don't edit).
+  They come from the SDK bundled in the CLI; \`lecodes update\` refreshes them from the platform.
+- \`.lecodes/\` is gitignored — per-checkout state (those types + \`manifest.json\`, this machine's
+  sync cursor once linked). After a fresh git clone: \`lecodes update\`, then
+  \`lecodes link --project <uuid>\` to re-attach.
+- \`.lecodesignore\` — files a future \`lecodes push\` would skip
+
+Full command list: \`lecodes --help\`.
+`
+
+export default defineCommand({
+  name: "init",
+  summary: "Scaffold a new LOCAL project (no login, no server)",
+  usage: "[dir]",
+  description: "Writes a starter main.ts, a CLAUDE.md + a passing flow test (the headless render / test loop), the IDE types + tsconfig, and a .lecodesignore. Run it with `lecodes dev` or `lecodes compile`. Idempotent: existing files are kept.",
+  flags: { desktop: bool("also write an app.json declaring the desktop target (window size; `dev --desktop`, `desktop run` and headless render / test pick it up)") },
+  examples: ["lecodes init myapp", "lecodes init --desktop"],
+  run: ({ args, flags }) => init(args[0], flags.desktop),
+})
+
+const init = (dir: string | undefined, forDesktop: boolean): void => {
+  const dirArg = (dir ?? ".").replace(/[/\\]+$/, "") || "."
+  const root = resolve(dirArg)
+  const name = basename(root)
+
+  mkdirSync(root, { recursive: true })
+
+  let created = 0
+  const write = (rel: string, content: string) => {
+    const abs = join(root, rel)
+    if (existsSync(abs)) { note(`kept      ${rel}`); return }
+    mkdirSync(dirname(abs), { recursive: true })
+    writeFileSync(abs, content)
+    log(`${c.green("created")}   ${rel}`)
+    created++
+  }
+
+  // Starter entry — a root file named main.ts is always the detected entrypoint.
+  write("main.ts", STARTER)
+  write("README.md", readmeTemplate(name))
+  // --desktop: an app.json declaring the desktop target (window config in logical units).
+  if (forDesktop) write("app.json", appJsonDesktop(name))
+  // AI-assistant guidance + a passing flow test: the headless loop is discoverable from day one.
+  write("CLAUDE.md", appClaudeMd(name))
+  write(".claude/settings.json", CLAUDE_SETTINGS)
+  write("tests/counter.flow.json", STARTER_FLOW)
+  // Keep local render/preview outputs (screenshot.png, shots/) out of any future push.
+  write(".lecodesignore", DEFAULT_IGNORE_FILE)
+  // .lecodes/ is per-checkout state (generated types + the push cursor) — keep it out of git.
+  const gi = ensureGitignore(root)
+  if (gi === "created") { log(`${c.green("created")}   .gitignore`); created++ }
+  else if (gi === "updated") log(`${c.green("updated")}   .gitignore  ${c.dim("(+ .lecodes/)")}`)
+  else note("kept      .gitignore")
+
+  // IDE types: the SDK's import-free global surface + a tsconfig, so VS Code resolves UIScreen,
+  // Scene2D, setLoop, … with no server. Regenerated every run to pick up CLI upgrades.
+  const wroteTypes = materializeTypesLocal(root)
+  writeTsconfig(root)
+  log(`${c.green("written")}   tsconfig.json${wroteTypes ? ` + ${LECODES_DIR}/types/` : ""}  (IDE types)`)
+  if (!wroteTypes) {
+    warnErr("Bundled SDK types not found — tsconfig written, but globals may show unresolved until the CLI is rebuilt with vendored types.")
+  }
+
+  log("")
+  success(created
+    ? `Local project ${c.bold(name)} ready${dirArg === "." ? "" : ` in ${c.bold(dirArg)}/`}.`
+    : `Project ${c.bold(name)} already initialized.`)
+  const cd = dirArg === "." ? "" : `cd ${dirArg} && `
+  if (forDesktop) {
+    log(`  ${c.bold(cd + "lecodes dev --desktop")}      run it in a desktop window with hot reload`)
+    log(`  ${c.bold(cd + "lecodes test")}               run the flow tests headless (desktop-sized)`)
+    log(`  ${c.bold(cd + "lecodes desktop run")}        open the compiled app in the desktop host`)
+  } else {
+    log(`  ${c.bold(cd + "lecodes dev")}                run it on a device with hot reload`)
+    log(`  ${c.bold(cd + "lecodes test")}               run the flow tests headless (no device)`)
+    log(`  ${c.bold(cd + "lecodes compile -o app.js")}  bundle it for LeCodes Desktop`)
+  }
+}

package/src/commands/plugin.ts

@@ -14,17 +14,17 @@ const gen = defineCommand({
   name: "gen",
   summary: "Generate a plugin's files from its contract.d.ts (--check: fail on a stale one)",
   usage: "[path]",
-  description: "The path is one plugin (a directory with a contract.d.ts) or a repo that keeps its plugins in plugins/<id>/; the current directory when omitted.\n\nWrites sdk/<id>.gen.ts — the wrapper an app calls: the wire call by call, the class with the wire's methods as its own, and the public export when the plugin has no hand-written sdk/<id>.ts. Where the plugin has an ios/ folder, writes ios/<Name>.gen.swift — the contract's types, the protocol the plugin implements and the glue that reads a call off the wire. Where it has an android/ folder, writes the same as <Name>.gen.kt into the folder of the plugin's Kotlin package (android/ is laid out as a Gradle module: the package is the folder the path under android/src/main/java narrows down to). Where it has a web/ folder, writes web/<id>.gen.ts — the same for the web half, in a file that imports nothing; a web half that imports a LeCodes package is refused, because it would run on that host only. A repo of plugins also gets its Package.swift from the manifests: the iOS halves as one SwiftPM package, a target and a product per plugin, the SDK as a package on disk (LECODES_IOS_SDK_PATH, else the repo's package.json lecodes.iosSdkPath, else ../lecodes) — what an Xcode project links the halves as (a shell vendors the sources instead). A contract the generator does not understand is an error with its line, and every problem of a file is reported at once.\n\nGenerated files are committed. Reading a contract needs TypeScript in the plugin's repo.",
+  description: "The path is one plugin (a directory with a contract.d.ts) or a repo that keeps its plugins in plugins/<id>/; the current directory when omitted.\n\nWrites sdk/<id>.gen.ts — the wrapper an app calls: the wire call by call, the class with the wire's methods as its own, and the public export when the plugin has no hand-written sdk/<id>.ts. Where the plugin has an ios/ folder, writes ios/<Name>.gen.swift — the contract's types, the protocol the plugin implements and the glue that reads a call off the wire. Where it has an android/ folder, writes the same as <Name>.gen.kt into the folder of the plugin's Kotlin package (android/ is laid out as a Gradle module: the package is the folder the path under android/src/main/java narrows down to). Where it has a web/ folder, writes web/<id>.gen.ts — the same for the web half, in a file that imports nothing; a web half that imports a LeCodes package is refused, because it would run on that host only. A repo of plugins also gets its Package.swift from the manifests: the iOS halves as one SwiftPM package, a target and a product per plugin, the SDK as a package on disk (LECODES_IOS_SDK_PATH, else the repo's package.json lecodes.iosSdkPath, else ../lecodes) — what an Xcode project links the halves as (a shell vendors the sources instead). A contract the generator does not understand is an error with its line, and every problem of a file is reported at once.\n\nA HALF FOLDER of a project — a manifest with `implements: \"<first-party id>\"`, no contract.d.ts and no sdk/ of its own — is generated from the contract of the plugin it implements (the one the SDK carries): `lecodes plugin gen plugins/ar-8thwall` writes web/ar.gen.ts, the half registers the service \"ar\", and app.json names the folder for that platform (`\"ar\": { \"web\": \"./plugins/ar-8thwall\" }`).\n\nGenerated files are committed. Reading a contract needs TypeScript in the plugin's repo.",
   flags: {
     check: bool("write nothing; exit 1 when a generated file is missing or stale"),
   },
-  examples: ["lecodes plugin gen", "lecodes plugin gen plugins/camera", "lecodes plugin gen --check"],
+  examples: ["lecodes plugin gen", "lecodes plugin gen plugins/camera", "lecodes plugin gen plugins/ar-8thwall", "lecodes plugin gen --check"],
   run: ({ args, flags }) => {
     const report = generate(args[0] ?? ".", { check: flags.check })
 
     for (const p of report.plugins) {
       const channels = p.contract.channels.map(ch => `${ch.kind} "${ch.name}" v${ch.version}`).join(", ")
-      info(`${c.bold(p.id)}  ${c.dim(channels)}`)
+      info(`${c.bold(p.id)}  ${c.dim(channels)}${p.implements ? c.dim(`  (implements ${p.implements}: the SDK's contract)`) : ""}`)
       for (const f of p.written) log(c.green(`  written   ${f}`))
       for (const f of p.stale) log(c.red(`  stale     ${f}`))
       for (const f of p.fresh) log(c.dim(`  fresh     ${f}`))

package/src/commands/push.ts

@@ -3,7 +3,7 @@ import { basename } from "node:path"
 import { CliError, bool, c, confirm, defineCommand, info, log, prompt, str, success, warn } from "../cli"
 import { getCommits, getProject, publishProject, sync, uploadBlob, type Project, type SyncFileInput, type SyncFolderInput, type SyncResponse } from "../platform/api"
 import { computeServerDiff } from "../platform/serverDiff"
-import { classifyKind, diffLocal, hasChanges, isTextKind, scanProject } from "../project/localFiles"
+import { diffLocal, hasChanges, isTextKind, scanProject } from "../project/localFiles"
 import { writeManifest, type FileKind, type Manifest, type ManifestFile } from "../project/manifest"
 import { buildPaths } from "../project/materialize"
 import { qrUrl, reportRelease, withSchemaConfirm } from "./releases"
@@ -107,7 +107,7 @@ export const runPush = async (opts: PushOptions): Promise<void> => {
   let uploaded = 0
   for (const file of scan.files) {
     const source = sourceFor(file.path)
-    const kind: FileKind = source?.type ?? classifyKind(basename(file.path))
+    const kind: FileKind = source?.type ?? file.kind
     const entry: SyncFileInput = { path: file.path, type: kind }
     if (source) entry.assetId = source.id
     if (isTextKind(kind)) entry.text = readFileSync(file.absPath, "utf8")

package/src/commands/shared.ts

@@ -1,79 +1,79 @@
-import { basename } from "node:path"
-import { bool, str, type FlagValues } from "../cli"
-import { loadConfig, requireApiUrl, requireToken } from "../platform/config"
-import { findProjectRoot, readManifest, type Manifest } from "../project/manifest"
-
-/*
- * What several commands share: the flag groups (spread into a command's `flags:`) and the
- * "where am I / who am I" lookups every platform command starts with.
- */
-
-// ---- flag groups -----------------------------------------------------------------------------
-
-/** How the project is compiled — `compile`, `dev`, `render`, `test`, `desktop run`, `app sync` … */
-export const bundleFlags = {
-  entry: str("compile from this entry instead of the detected one", { value: "<path>" }),
-  "public-url": str("resolve assets from this URL prefix (default: the API origin / the working tree)", { value: "<url>" }),
-  "remote-assets": bool("desktop hosts: load asset() resources from the server instead of the working tree"),
-  "no-header": bool("omit the metadata header"),
-  "no-minify": bool("keep the bundle readable (no compress / mangle)"),
-  "no-sourcemap": bool("don't generate / inline the source map"),
-}
-
-/** `-o` for commands whose result is a file. */
-export const outFlag = { out: str("write to this file instead of stdout", { alias: "o", value: "<file>" }) }
-
-/** The compiler's view of the bundle flags (see compile.ts `buildBundle`). */
-export type BundleOptions = {
-  entry?: string
-  publicUrl?: string
-  remoteAssets?: boolean
-  header?: boolean
-  minify?: boolean
-  sourcemap?: boolean
-}
-
-export const bundleOptions = (flags: FlagValues<typeof bundleFlags>): BundleOptions => ({
-  entry: flags.entry,
-  publicUrl: flags["public-url"],
-  remoteAssets: flags["remote-assets"],
-  header: !flags["no-header"],
-  // Both default on; `false` only when the flag is present, so the SDK's own defaults stand.
-  minify: flags["no-minify"] ? false : undefined,
-  sourcemap: flags["no-sourcemap"] ? false : undefined,
-})
-
-// ---- where / who -----------------------------------------------------------------------------
-
-export type Session = { apiUrl: string, token: string }
-
-/** The logged-in session (api origin + token) or a "run `lecodes login`" error. */
-export const session = (): Session => {
-  const config = loadConfig()
-  return { apiUrl: requireApiUrl(config), token: requireToken(config) }
-}
-
-export type LinkedProject = Session & { root: string, manifest: Manifest }
-
-/** A server-backed checkout: the project root (found upward from the cwd), its manifest and the session. */
-export const linkedProject = (): LinkedProject => {
-  const root = findProjectRoot(process.cwd())
-  return { root, manifest: readManifest(root), ...session() }
-}
-
-export type LocalProject = { root: string, manifest: Manifest | null, name: string }
-
-/** Any project: a linked checkout, else the current folder standing alone (no login needed). */
-export const localProject = (): LocalProject => {
-  try {
-    const root = findProjectRoot(process.cwd())
-    const manifest = readManifest(root)
-    return { root, manifest, name: manifest.name }
-  } catch {
-    const root = process.cwd()
-    return { root, manifest: null, name: basename(root) }
-  }
-}
-
-/** A folder name for a project: lower-case, dashes, never empty. */
-export const slugOf = (name: string): string => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project"
+import { basename } from "node:path"
+import { bool, str, type FlagValues } from "../cli"
+import { loadConfig, requireApiUrl, requireToken } from "../platform/config"
+import { findProjectRoot, readManifest, type Manifest } from "../project/manifest"
+
+/*
+ * What several commands share: the flag groups (spread into a command's `flags:`) and the
+ * "where am I / who am I" lookups every platform command starts with.
+ */
+
+// ---- flag groups -----------------------------------------------------------------------------
+
+/** How the project is compiled — `compile`, `dev`, `render`, `test`, `desktop run`, `app sync` … */
+export const bundleFlags = {
+  entry: str("compile from this entry instead of the detected one", { value: "<path>" }),
+  "public-url": str("resolve assets from this URL prefix (default: the API origin / the working tree)", { value: "<url>" }),
+  "remote-assets": bool("desktop hosts: load asset() resources from the server instead of the working tree"),
+  "no-header": bool("omit the metadata header"),
+  "no-minify": bool("keep the bundle readable (no compress / mangle)"),
+  "no-sourcemap": bool("don't generate / inline the source map"),
+}
+
+/** `-o` for commands whose result is a file. */
+export const outFlag = { out: str("write to this file instead of stdout", { alias: "o", value: "<file>" }) }
+
+/** The compiler's view of the bundle flags (see compile.ts `buildBundle`). */
+export type BundleOptions = {
+  entry?: string
+  publicUrl?: string
+  remoteAssets?: boolean
+  header?: boolean
+  minify?: boolean
+  sourcemap?: boolean
+}
+
+export const bundleOptions = (flags: FlagValues<typeof bundleFlags>): BundleOptions => ({
+  entry: flags.entry,
+  publicUrl: flags["public-url"],
+  remoteAssets: flags["remote-assets"],
+  header: !flags["no-header"],
+  // Both default on; `false` only when the flag is present, so the SDK's own defaults stand.
+  minify: flags["no-minify"] ? false : undefined,
+  sourcemap: flags["no-sourcemap"] ? false : undefined,
+})
+
+// ---- where / who -----------------------------------------------------------------------------
+
+export type Session = { apiUrl: string, token: string }
+
+/** The logged-in session (api origin + token) or a "run `lecodes login`" error. */
+export const session = (): Session => {
+  const config = loadConfig()
+  return { apiUrl: requireApiUrl(config), token: requireToken(config) }
+}
+
+export type LinkedProject = Session & { root: string, manifest: Manifest }
+
+/** A server-backed checkout: the project root (found upward from the cwd), its manifest and the session. */
+export const linkedProject = (): LinkedProject => {
+  const root = findProjectRoot(process.cwd())
+  return { root, manifest: readManifest(root), ...session() }
+}
+
+export type LocalProject = { root: string, manifest: Manifest | null, name: string }
+
+/** Any project: a linked checkout, else the current folder standing alone (no login needed). */
+export const localProject = (): LocalProject => {
+  try {
+    const root = findProjectRoot(process.cwd())
+    const manifest = readManifest(root)
+    return { root, manifest, name: manifest.name }
+  } catch {
+    const root = process.cwd()
+    return { root, manifest: null, name: basename(root) }
+  }
+}
+
+/** A folder name for a project: lower-case, dashes, never empty. */
+export const slugOf = (name: string): string => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project"