@mosetta/cli 0.0.0-stage → 0.0.9

package/src/typecheck.mjs

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { sectionLog } from './log.mjs';
+
+// App-level typecheck: the build pipeline itself never checks types (esbuild strips them
+// blindly), so the CLI runs the CONSUMER'S OWN tsc against the app root — @mosetta/core ships
+// `typescript` as a dependency, so any mosetta closure has a binary to resolve. Both entry
+// points are safe-to-lose: no tsconfig / no typescript / checker crash → one notice line and
+// the dev/build flow continues exactly as before the feature existed.
+
+function typecheckTargets(root) {
+  const tsconfig = path.join(root, 'tsconfig.json');
+  if (!fs.existsSync(tsconfig)) return { tsconfig: null, tscBin: null };
+  try {
+    const req = createRequire(path.join(root, 'package.json'));
+    const pkgPath = req.resolve('typescript/package.json');
+    return { tsconfig, tscBin: path.join(path.dirname(pkgPath), 'lib', 'tsc.js') };
+  } catch {
+    return { tsconfig, tscBin: null };
+  }
+}
+
+// tsc output line-by-line into the section log (headers/coloring live in the logger)
+function forwardTo(log) {
+  return (chunk) => {
+    const text = String(chunk).replace(/\n+$/, '');
+    if (text.trim()) log(text);
+  };
+}
+
+/** blocking gate for `mosetta build` — resolves false ONLY on real type errors */
+export function runTypecheck({ root, log = sectionLog('typescript') } = {}) {
+  const { tsconfig, tscBin } = typecheckTargets(root);
+  if (!tsconfig) {
+    log('no tsconfig.json at the app root — typecheck skipped');
+    return Promise.resolve(true);
+  }
+  if (!tscBin) {
+    log('typescript is not resolvable from the app root — typecheck skipped');
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    const child = spawn(
+      process.execPath,
+      [tscBin, '--noEmit', '-p', root, '--pretty', 'false'],
+      { stdio: ['ignore', 'pipe', 'pipe'] },
+    );
+    const forward = forwardTo(log);
+    child.stdout.on('data', forward);
+    child.stderr.on('data', forward);
+    child.on('error', () => resolve(true)); // checker failed to run ≠ type errors
+    child.on('exit', (code) => resolve(code === 0));
+  });
+}
+
+/**
+ * Dev companion (the fork-ts-checker idea without the plugin bridge): tsc has its own watcher
+ * and incremental checker, so a plain `tsc --watch` child next to the dev server is enough —
+ * it never blocks or slows rebuilds, its findings go to the dev log under the section header.
+ */
+export function startTypecheckWatch({ root, log = sectionLog('typescript'), onResult } = {}) {
+  const { tsconfig, tscBin } = typecheckTargets(root);
+  if (!tsconfig || !tscBin) return null;
+  const child = spawn(
+    process.execPath,
+    [tscBin, '--noEmit', '-p', root, '--watch', '--preserveWatchOutput', '--pretty', 'false'],
+    { stdio: ['ignore', 'pipe', 'pipe'] },
+  );
+  let stopped = false;
+  const forward = forwardTo(log);
+  // `tsc --watch` has no "run started" marker, it just writes to the stream. But its END is
+  // explicit — the "Found N errors" line. So we buffer the stream up to that line and report
+  // on it: no errors → the status section clears, errors → the accumulated text goes there.
+  const DONE_RE = /Found (\d+) errors?/;
+  let buffer = '';
+  const collect = (chunk) => {
+    forward(chunk);
+    if (!onResult) return;
+    buffer += String(chunk);
+    const done = DONE_RE.exec(buffer);
+    if (!done) {
+      if (buffer.length > 200_000) buffer = buffer.slice(-100_000); // in case the stream never emits the marker
+      return;
+    }
+    const errors = Number(done[1]) > 0
+      // messages are lines like `file(1,2): error TS…`; watcher noise stays out of status
+      ? buffer.split('\n').filter((l) => l.includes('error TS')).join('\n').trim()
+      : null;
+    onResult(errors || null);
+    buffer = '';
+  };
+  child.stdout.on('data', collect);
+  child.stderr.on('data', collect);
+  child.on('error', () => { /* safe-to-lose: dev runs without live typecheck */ });
+  child.on('exit', (code) => {
+    if (!stopped) log(`checker exited (code=${code}) — dev continues without live typecheck`);
+  });
+  return {
+    child,
+    stop() {
+      stopped = true;
+      try { child.kill(); } catch { /* ignore */ }
+    },
+  };
+}

package/src/version.mjs

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { sectionLog } from './log.mjs';
+
+// `mosetta version <patch|minor|major> [--package <namespace | package name>]`: a deployed
+// version never changes (deploy.mjs refuses new bytes under it), so a change ships under a new
+// one. This raises it where it lives — the `version` of the distribution's package.json — and
+// nothing else: the build names every module after it.
+
+const LEVELS = ['patch', 'minor', 'major'];
+
+/** the next X.Y.Z at `level` */
+export function nextVersion(version, level) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version ?? '');
+  if (!match) throw new Error(`version "${version}" is not X.Y.Z`);
+  if (!LEVELS.includes(level)) throw new Error(`"${level}" is not one of ${LEVELS.join(', ')}`);
+  const [major, minor, patch] = match.slice(1).map(Number);
+  if (level === 'major') return `${major + 1}.0.0`;
+  if (level === 'minor') return `${major}.${minor + 1}.0`;
+  return `${major}.${minor}.${patch + 1}`;
+}
+
+const readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));
+
+/** the directory of a package resolved from the app's root — walked up from its entry */
+function packageDirOfName(root, name) {
+  const requireFromRoot = createRequire(path.join(root, 'package.json'));
+  let dir = path.dirname(fs.realpathSync(requireFromRoot.resolve(name)));
+  for (;;) {
+    const file = path.join(dir, 'package.json');
+    if (fs.existsSync(file) && readJson(file).name === name) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) throw new Error(`package ${name}: its package.json was not found`);
+    dir = parent;
+  }
+}
+
+/**
+ * The directory of what `target` names: a package name (`@acme/ui`), a tile palette's brand
+ * (`acme-ui` — the app itself or one of its libraries), or — nothing named — the app itself.
+ */
+export function distributionDir(root, target) {
+  if (!target) return root;
+  if (target.startsWith('@') || target.includes('/')) return packageDirOfName(root, target);
+  const config = readJson(path.join(root, 'mosetta.json'));
+  if (config.brand === target) return root;
+  for (const library of [...(config.libraries ?? []), ...(config.devLibraries ?? [])]) {
+    const dir = packageDirOfName(root, library);
+    const own = path.join(dir, 'mosetta.json');
+    if (fs.existsSync(own) && readJson(own).brand === target) return dir;
+  }
+  throw new Error(`no tile palette of ${root} has the brand "${target}"`);
+}
+
+/** raise the version of `target` at `level`; the package.json keeps its own formatting */
+export function raiseVersion(root, { target, level, log = sectionLog('version') } = {}) {
+  const dir = distributionDir(root, target);
+  const file = path.join(dir, 'package.json');
+  const text = fs.readFileSync(file, 'utf8');
+  const { name, version } = JSON.parse(text);
+  const next = nextVersion(version, level);
+  fs.writeFileSync(file, text.replace(/("version"\s*:\s*")[^"]*(")/, `$1${next}$2`));
+  log(`${name}: ${version} → ${next}`);
+  return { name, from: version, to: next, dir };
+}

package/src/wasmEngine.mjs

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+
+/**
+ * The ONLY build engine of the framework: `@rollup/browser` for the module graph +
+ * `esbuild-wasm` for transpilation and private monoliths. The same set ships into the isolate,
+ * so dev, CI and the platform build the graph with the same code.
+ *
+ * We deliberately have no native binaries: per-OS platform builds (and their differences),
+ * optional dependencies in CI and differential "two engines produce the same bytes" checks are
+ * a class of problems that simply never arises with a single wasm engine. Extra speed — the
+ * `mosetta.engine.mjs` hook (engineLoader.mjs); the rules of the game then shift to the developer.
+ *
+ * IMPORTANT about the FS: a wasm build has no FS of ITS OWN, it takes the host's syscall shim —
+ * in node that is the real `fs` (the engine reads the disk!), in workerd — nothing. So "wasm
+ * engine" does not guarantee portability by itself; the gate is the virtual world (memory FS).
+ */
+
+// `@rollup/browser` targets the browser and pulls its wasm via `fetch` from `import.meta.url`.
+// In node the file:// scheme has no fetch. We install a NARROW shim: only file://*.wasm is read
+// from disk, everything else delegates to the real fetch. The isolate does not need this shim —
+// wasm arrives there as a declared module (workerd forbids runtime wasm compilation).
+let fetchPatched = false;
+function installFileWasmFetch() {
+  if (fetchPatched) return;
+  fetchPatched = true;
+  const original = globalThis.fetch;
+  globalThis.fetch = async (input, init) => {
+    const url = String(input?.url ?? input);
+    if (url.startsWith('file://') && url.endsWith('.wasm')) {
+      return new Response(fs.readFileSync(new URL(url)), { headers: { 'content-type': 'application/wasm' } });
+    }
+    return original(input, init);
+  };
+}
+
+// esbuild-wasm initializes EXACTLY ONCE per process — a second call throws
+let engine = null;
+export function createWasmEngine() {
+  if (!engine) engine = build();
+  return engine;
+}
+
+async function build() {
+  installFileWasmFetch();
+  const [{ rollup }, esbuild] = await Promise.all([
+    import('@rollup/browser'),
+    import('esbuild-wasm'),
+  ]);
+  await esbuild.initialize({ worker: false });
+  return {
+    rollup,
+    transform: (code, options) => esbuild.transform(code, options),
+    bundle: (options) => esbuild.build(options),
+  };
+}

package/src/workerd.mjs

@@ -0,0 +1,172 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+// Locate the workerd binary. The `workerd` npm package's default export is the path to the platform
+// binary (like esbuild); fall back to its bin shim, then PATH.
+export function resolveWorkerdBin() {
+  try {
+    const p = require('workerd');
+    if (typeof p === 'string') return p;
+    if (p && typeof p.default === 'string') return p.default;
+  } catch { /* not installed yet */ }
+  try {
+    return require.resolve('workerd/bin/workerd');
+  } catch { /* ignore */ }
+  return 'workerd'; // assume on PATH
+}
+
+// Write the bundled worker + a .capnp config into a fresh temp dir. The worker fetches artifacts/pages
+// from the static provider over HTTP, so it needs outbound to localhost (private/local) — granted via a
+// permissive `internet` network service set as globalOutbound. PROVIDER_ORIGIN comes in as a text binding.
+// ctx.exports (loopback RPC bindings) became a default in workerd on this date; before it, the
+// flag is required — and naming it on a later date is an error
+const CTX_EXPORTS_DEFAULT_SINCE = '2025-11-17';
+
+export function writeWorkerdConfig({
+  workerCode, port, providerOrigin, compatibilityDate = '2024-11-01',
+  staticDir = null, appRoot = null, contentRoot = null, providersJson = null,
+}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mosetta-workerd-'));
+  fs.writeFileSync(path.join(dir, 'worker.js'), workerCode);
+
+  // ONE PORT in dev: workerd serves static itself, so a single address is exposed outward
+  // (cloudflared/ngrok tunnel). The byte source is a DIRECTORY ON DISK written by node: the
+  // `disk` service reads it per request — no separate store or upload protocol is needed.
+  // Generations and the lock file live there too.
+  // Write boundaries are held by the CONFIG: the worker sees exactly the app's `pages/` and
+  // `prefabs/` (writable) and the root (read-only — the runtime `config.json` lives there).
+  // Writing into source code is physically impossible for it.
+  const devServices = staticDir
+    ? `
+    (name = "files", disk = (path = ${JSON.stringify(staticDir)}, writable = false)),`
+      + (appRoot ? `
+    (name = "pages", disk = (path = ${JSON.stringify(`${contentRoot ?? appRoot}/pages`)}, writable = true)),
+    (name = "prefabs", disk = (path = ${JSON.stringify(`${contentRoot ?? appRoot}/prefabs`)}, writable = true)),
+    (name = "media", disk = (path = ${JSON.stringify(`${contentRoot ?? appRoot}/media`)}, writable = true)),
+    (name = "app", disk = (path = ${JSON.stringify(appRoot)}, writable = false)),
+    (name = "secrets", disk = (path = ${JSON.stringify(path.join(appRoot, '.mosetta'))}, writable = false)),` : '')
+    : '';
+  const devBindings = staticDir
+    ? `
+    (name = "FILES", service = "files"),`
+      + (appRoot ? `
+    (name = "PAGES", service = "pages"),
+    (name = "PREFABS", service = "prefabs"),
+    (name = "MEDIA", service = "media"),
+    (name = "APP", service = "app"),
+    # the project's dev secrets: .mosetta/secrets.json, read by the DevSecrets entrypoint only
+    (name = "DEV_SECRETS", service = "secrets"),` : '')
+    : '';
+
+  const capnp = `using Workerd = import "/workerd/workerd.capnp";
+
+const config :Workerd.Config = (
+  services = [
+    (name = "main", worker = .mainWorker),
+    (name = "internet", network = (allow = ["public", "private", "local"])),${devServices}
+  ],
+  sockets = [
+    (name = "http", address = "127.0.0.1:${port}", http = (), service = "main"),
+  ],
+);
+
+const mainWorker :Workerd.Worker = (
+  modules = [
+    (name = "worker.js", esModule = embed "worker.js"),
+  ],
+  compatibilityDate = "${compatibilityDate}",${compatibilityDate < CTX_EXPORTS_DEFAULT_SINCE ? `
+  # ctx.exports: the store capability stubs isolates get instead of keys (default since ${CTX_EXPORTS_DEFAULT_SINCE})
+  compatibilityFlags = ["enable_ctx_exports"],` : ''}
+  globalOutbound = "internet",
+  bindings = [
+    # the app's provider when no trusted-layer headers arrive (dev default)
+    (name = "DEFAULT_PROVIDER_ORIGIN", text = ${JSON.stringify(providerOrigin)}),${providersJson ? `
+    # EXPLICIT provider registry with credentials: the runner registry + the dev-S3 key table
+    (name = "PROVIDERS", text = ${JSON.stringify(providersJson)}),` : ''}
+    # Worker Loader: the thin runner composes EVERY isolate with it. Requires --experimental.
+    (name = "LOADER", workerLoader = ()),${devBindings}
+  ],
+);
+`;
+  const configPath = path.join(dir, 'config.capnp');
+  fs.writeFileSync(configPath, capnp);
+  return { dir, configPath };
+}
+
+/**
+ * Is the port free. Before startup this matters more than it seems: a workerd copy that survived
+ * a previous run holds the address, the new one silently fails to come up — and a "readiness
+ * timed out" message points the wrong way.
+ */
+export function probePort(port, host = '127.0.0.1') {
+  return new Promise((resolve) => {
+    const socket = net.connect({ port, host });
+    const done = (busy) => {
+      socket.destroy();
+      resolve(busy);
+    };
+    socket.once('connect', () => done(true));
+    socket.once('error', () => done(false));
+    socket.setTimeout(500, () => done(false));
+  });
+}
+
+/**
+ * Kill the workerd child for sure: politely first (SIGTERM), then SIGKILL, and wait for the
+ * actual exit. Otherwise a surviving copy occupies the port and the next `mosetta dev` cannot
+ * start (workerd does not always die instantly on SIGTERM, and its inherited stdio pipes also
+ * keep the parent alive).
+ */
+export async function killWorkerd(child, { graceMs = 1500, forceMs = 1500 } = {}) {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return true;
+  const exited = (ms) => new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null) return resolve(true);
+    const timer = setTimeout(() => resolve(false), ms);
+    child.once('exit', () => {
+      clearTimeout(timer);
+      resolve(true);
+    });
+  });
+  try { child.kill('SIGTERM'); } catch { /* already dead */ }
+  if (await exited(graceMs)) return true;
+  try { child.kill('SIGKILL'); } catch { /* already dead */ }
+  return exited(forceMs);
+}
+
+// Spawn `workerd serve config.capnp` and wait until it answers HTTP.
+// `log` (optional) wraps workerd output into the section log; without it — inherit as before.
+export async function spawnWorkerd({ binPath, configPath, port, timeoutMs = 15000, log = null }) {
+  // --experimental enables the Worker Loader binding (server-action isolates).
+  const stdio = log ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'inherit', 'inherit'];
+  const child = spawn(binPath, ['serve', configPath, '--experimental'], { stdio });
+  if (log) {
+    const forward = (chunk) => {
+      const text = String(chunk).replace(/\n+$/, '');
+      if (text.trim()) log(text);
+    };
+    child.stdout.on('data', forward);
+    child.stderr.on('data', forward);
+  }
+  let exited = null;
+  child.on('exit', (code, signal) => { exited = { code, signal }; });
+
+  const deadline = Date.now() + timeoutMs;
+  const url = `http://127.0.0.1:${port}/__mosetta_ping__`;
+  while (Date.now() < deadline) {
+    if (exited) throw new Error(`workerd exited early (code=${exited.code} signal=${exited.signal})`);
+    try {
+      await fetch(url); // any HTTP response (incl. 404) means the socket is up
+      return child;
+    } catch {
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+  try { child.kill(); } catch { /* ignore */ }
+  throw new Error(`workerd did not become ready on :${port} within ${timeoutMs}ms`);
+}