@rubytech/create-maxy-lite 0.1.2 → 0.1.4

package/index.mjs

@@ -23,7 +23,7 @@ import { fileURLToPath } from 'node:url'
 
 import { makeLog } from './lib/log.mjs'
 import { readPins } from './lib/pins.mjs'
-import { PATHS, WEBCHAT_DIR, VALIDATOR_CLI, launcherPath, launcherScript } from './lib/paths.mjs'
+import { PATHS, WEBCHAT_DIR, VALIDATOR_CLI, launcherPath, launcherScript, payloadLayCommand, vaultBindLogin, webchatRunEnv } from './lib/paths.mjs'
 import { orchestrate, STEP_NAMES } from './lib/orchestrate.mjs'
 import { claudeOk, validatorOk, vaultOk, webchatOk, healthcheck } from './lib/healthcheck.mjs'
 
@@ -73,11 +73,9 @@ const runStream = (cmd) => spawnStreaming('bash', ['-lc', cmd])
 const runInStream = (cmd) => spawnStreaming('proot-distro', ['login', PATHS.distro, '--', 'bash', '-lc', cmd])
 
 // ---- filesystem primitives --------------------------------------------------
-// The Ubuntu rootfs is a normal directory under the Termux prefix, so the app
-// payload is copied into it directly from bionic Node (no proot round-trip).
-
-const rootfs = `${PREFIX}/var/lib/proot-distro/installed-rootfs/${PATHS.distro}`
-const appHostPath = `${rootfs}${PATHS.appDir}` // appDir is absolute inside the rootfs
+// Host-side fs is used only for genuine host paths (the Termux-prefix launcher
+// and the shared-storage vault). The app payload lands inside the rootfs through
+// proot (see layPayload), never via a reconstructed host rootfs path.
 
 const existsHost = (p) => fs.existsSync(p)
 const mkdirHost = (p) => fs.mkdirSync(p, { recursive: true })
@@ -101,20 +99,38 @@ const storageAccessible = () => {
 const interactive = Boolean(process.stdin.isTTY)
 const STORAGE_POLL_MS = 3000
 
-/** Copy the bundled app payload into the Ubuntu rootfs (idempotent overwrite). */
+/** Lay the bundled app payload into the guest's appDir through proot (idempotent overwrite). */
+// Delivered via a proot bind + guest-side copy so the payload lands in whatever
+// rootfs proot-distro actually uses — no host-side guess at the rootfs location.
 const layPayload = () => {
-  fs.mkdirSync(appHostPath, { recursive: true })
-  fs.cpSync(PAYLOAD, appHostPath, { recursive: true })
+  const r = run(payloadLayCommand({ payloadHost: PAYLOAD }))
+  if (r.code !== 0) throw new Error(`payload lay failed: ${r.stderr.replace(/\s+/g, ' ').trim()}`)
 }
 
 /** Install the app deps (validator's js-yaml) and the webchat deps (node-pty, ws). */
 // Streamed: the webchat deps build node-pty natively, which is slow and verbose;
 // a failure carries the child's stderr so the cause is in the log.
+const PTY_NODE = `${WEBCHAT_DIR}/node_modules/node-pty/build/Release/pty.node`
 const installDeps = async () => {
   const app = await runInStream(`cd ${PATHS.appDir} && npm install --omit=dev`)
   if (app.code !== 0) throw new Error(`app deps install failed: ${app.stderr.replace(/\s+/g, ' ').trim()}`)
   const wc = await runInStream(`cd ${WEBCHAT_DIR} && npm install --omit=dev`)
   if (wc.code !== 0) throw new Error(`webchat deps install failed: ${wc.stderr.replace(/\s+/g, ' ').trim()}`)
+  // node-pty ships no linux-arm64 + Node 20 prebuild, so the install above can
+  // leave pty.node unbuilt when npm has ignore-scripts set. `npm rebuild` re-runs
+  // node-pty's node-gyp build; the env var forces scripts on regardless of ambient
+  // config, and --build-from-source keeps it a source compile should a future
+  // node-pty gain a prebuild fetcher. The toolchain step guarantees python3/make/g++.
+  const rb = await runInStream(
+    `cd ${WEBCHAT_DIR} && npm_config_ignore_scripts=false npm rebuild node-pty --build-from-source --foreground-scripts`,
+  )
+  if (rb.code !== 0) throw new Error(`node-pty native build failed: ${rb.stderr.replace(/\s+/g, ' ').trim()}`)
+  // Prove the built module actually loads under the guest's Node — this is exactly
+  // what the relay does at launch, so a pass here means no `Failed to load native
+  // module: pty.node` crash. A bare file-presence test would miss an unloadable
+  // binary. Fail at install time, not at relay launch.
+  if (runIn(`cd ${WEBCHAT_DIR} && node -e 'require("node-pty")'`).code !== 0)
+    throw new Error(`node-pty native module did not load after build: ${PTY_NODE}`)
 }
 
 /** Write the `maxy-lite` launcher into the Termux bin dir. */
@@ -140,16 +156,20 @@ const readVersions = () => ({
 const runHealthcheck = () =>
   healthcheck({
     checkClaude: () => claudeOk(() => runIn('claude --version')),
-    // Start the relay, poll its port for up to 10s, record whether it bound, kill it.
+    // Start the relay under the launcher's exact runtime condition — the vault
+    // bound in and the launcher env set — then poll its port for up to 10s, record
+    // whether it bound, and kill it. Run from bare Termux (`run`) because
+    // vaultBindLogin already enters the distro; `runIn` would nest a second login
+    // with no bind and test the wrong process.
     checkWebchat: () =>
       webchatOk(async () => {
-        const probe =
-          `cd ${WEBCHAT_DIR} && node server.mjs & SVPID=$!; ` +
+        const inner =
+          `cd ${WEBCHAT_DIR} && ${webchatRunEnv()} node server.mjs & SVPID=$!; ` +
           `for i in $(seq 1 10); do sleep 1; ` +
           `curl -sf -o /dev/null http://localhost:${PATHS.webchatPort} && break; done; ` +
           `curl -sf -o /dev/null http://localhost:${PATHS.webchatPort}; RC=$?; ` +
           `kill $SVPID 2>/dev/null; exit $RC`
-        return runIn(probe).code === 0
+        return run(vaultBindLogin(inner)).code === 0
       }),
     // Validator must exit 0 on an empty vault.
     checkValidator: () => {
@@ -157,7 +177,10 @@ const runHealthcheck = () =>
       runIn(`mkdir -p ${empty}`)
       return validatorOk((vault) => runIn(`node ${VALIDATOR_CLI} ${vault}`).code, empty)
     },
-    checkVault: () => vaultOk(() => runIn(`test -d ${PATHS.vaultGuest}`).code === 0),
+    // The vault path only exists inside the distro when the login carries the
+    // launcher's `--bind`. Reproduce that bind, then check the guest path — exactly
+    // the launcher condition, not a session where the vault was never mounted.
+    checkVault: () => vaultOk(() => run(vaultBindLogin(`test -d ${PATHS.vaultGuest}`)).code === 0),
   })
 
 // ---- dry run ----------------------------------------------------------------

package/lib/orchestrate.mjs

@@ -109,11 +109,13 @@ const STEPS = [
   },
   {
     name: 'npm-app',
-    // Converged only when the deps are built, claude is present, AND the launcher
-    // is written — the launcher is the last mutation, so guarding on the first two
-    // alone would skip a half-finished install and report ok=true with no launcher.
+    // Converged only when node-pty's native module is built, claude is present,
+    // AND the launcher is written. The deps probe is the built `pty.node`, not the
+    // node_modules dir: node-pty ships no linux-arm64 prebuild, so a dir-present
+    // install can still lack the native module and crash the relay at launch.
+    // Guarding on pty.node makes a re-run rebuild it instead of skipping ok=true.
     done: (c) =>
-      c.runIn(`test -d ${WEBCHAT_DIR}/node_modules`).code === 0 &&
+      c.runIn(`test -f ${WEBCHAT_DIR}/node_modules/node-pty/build/Release/pty.node`).code === 0 &&
       c.runIn('command -v claude').code === 0 &&
       c.existsHost(launcherPath()),
     run: async (c) => {

package/lib/paths.mjs

@@ -21,15 +21,61 @@ export const PATHS = {
 export const WEBCHAT_DIR = `${PATHS.appDir}/webchat`
 export const VALIDATOR_CLI = `${PATHS.appDir}/validator/cli.mjs`
 
+// Where the host payload is bind-mounted inside the guest while it is copied into
+// place. A throwaway path under the rootfs's own /tmp, distinct from the app dir.
+export const PAYLOAD_STAGE = '/tmp/maxy-lite-payload'
+
+/**
+ * The bare-Termux command that lays the bundled app payload into the guest's
+ * `appDir`. It binds the host payload directory into the guest under `stage`,
+ * then copies it guest-side — so the payload always lands in whatever rootfs
+ * proot-distro actually uses, with no host-side guess at the rootfs location.
+ * `payloadHost` is the only environment-dependent path (the npm package's
+ * `payload/`), so it is single-quoted; `stage` and `appDir` are pinned constants.
+ */
+export function payloadLayCommand({ payloadHost, distro = PATHS.distro, stage = PAYLOAD_STAGE, appDir = PATHS.appDir }) {
+  return (
+    `proot-distro login ${distro} --bind '${payloadHost}':${stage} -- ` +
+    `bash -lc 'mkdir -p ${appDir} && cp -a ${stage}/. ${appDir}/'`
+  )
+}
+
 /** Absolute path of the `maxy-lite` launcher in the Termux bin dir. */
 export function launcherPath(prefix = process.env.PREFIX || '/data/data/com.termux/files/usr') {
   return `${prefix}/bin/maxy-lite`
 }
 
+/**
+ * The env prefix the webchat relay needs to serve the bound vault on the pinned
+ * port. Shared by the launcher and the webchat health-check probe so the two
+ * cannot drift: the probe must start the relay with exactly the env production
+ * uses, or it tests a different process than the one the launcher runs.
+ */
+export function webchatRunEnv({ vaultGuest = PATHS.vaultGuest, port = PATHS.webchatPort } = {}) {
+  return `LITE_AGENT_HOME=${vaultGuest} LITE_PORT=${port}`
+}
+
+/**
+ * A proot-distro login into the distro with the shared-storage vault bound in,
+ * running `inner` under `bash -lc`. This is the single construction of the
+ * launcher's runtime condition (the `--bind` that makes `${vaultGuest}` exist);
+ * the launcher and the vault/webchat probes all build on it so a probe can never
+ * assert a post-condition under different conditions than production.
+ * Run from bare Termux (not nested inside another `proot-distro login`).
+ */
+export function vaultBindLogin(
+  inner,
+  { distro = PATHS.distro, vaultHost = PATHS.vaultHost, vaultGuest = PATHS.vaultGuest } = {},
+) {
+  return `proot-distro login ${distro} --bind ${vaultHost}:${vaultGuest} -- bash -lc '${inner}'`
+}
+
 /**
  * The `maxy-lite` launcher script (written into the Termux bin dir). Run from the
  * Termux shell, it enters Ubuntu with the vault bind-mount and starts the webchat
- * relay on localhost. Documented Termux:Boot opt-in re-runs this on boot.
+ * relay on localhost. Built from the shared bind + env helpers so the launcher
+ * and the health-check probes stay in lockstep. Documented Termux:Boot opt-in
+ * re-runs this on boot.
  */
 export function launcherScript({
   prefix = process.env.PREFIX || '/data/data/com.termux/files/usr',
@@ -39,12 +85,12 @@ export function launcherScript({
   port = PATHS.webchatPort,
   distro = PATHS.distro,
 } = {}) {
+  const inner = `cd ${webchatDir} && ${webchatRunEnv({ vaultGuest, port })} exec node server.mjs`
   return `#!${prefix}/bin/bash
 # maxy-lite launcher — starts the on-device web chat relay.
 # Enters the glibc Ubuntu layer with the shared-storage vault bound in, then runs
 # the relay on http://localhost:${port}. Open that URL in the phone browser.
 set -e
-exec proot-distro login ${distro} --bind ${vaultHost}:${vaultGuest} -- \\
-  bash -lc 'cd ${webchatDir} && LITE_AGENT_HOME=${vaultGuest} LITE_PORT=${port} exec node server.mjs'
+exec ${vaultBindLogin(inner, { distro, vaultHost, vaultGuest })}
 `
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy-lite",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Install maxy-lite on an Android phone: orchestrates proot-distro Ubuntu, glibc Node, claude, the web-chat relay, the vault and its bind-mount — run via npx in bare Termux.",
   "type": "module",
   "engines": {