@rubytech/create-maxy-lite 0.1.1 → 0.1.3

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 } from './lib/paths.mjs'
 import { orchestrate, STEP_NAMES } from './lib/orchestrate.mjs'
 import { claudeOk, validatorOk, vaultOk, webchatOk, healthcheck } from './lib/healthcheck.mjs'
 
@@ -73,19 +73,38 @@ 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 })
 
-/** Copy the bundled app payload into the Ubuntu rootfs (idempotent overwrite). */
+// ---- shared-storage permission ----------------------------------------------
+// The vault lives on Android shared storage, whose parent (`/storage/emulated/0`)
+// is unwritable until Termux holds the shared-storage permission. `termux-setup-
+// storage` pops the Android grant dialog; the parent becomes writable once the
+// user taps Allow. Detection is the writability of that parent, not an existence
+// check — the directory can be present but inaccessible before the grant.
+
+const storageParent = path.dirname(PATHS.vaultHost)
+const storageAccessible = () => {
+  try {
+    fs.accessSync(storageParent, fs.constants.W_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+const interactive = Boolean(process.stdin.isTTY)
+const STORAGE_POLL_MS = 3000
+
+/** 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). */
@@ -168,6 +187,22 @@ async function main() {
     if (timer.unref) timer.unref()
     return () => clearInterval(timer)
   }
+  // Drive the Android shared-storage grant: surface the dialog, then poll the vault
+  // parent's writability until the user taps Allow. No timeout — the step heartbeat
+  // keeps the wait visibly alive — so a slow grant never fails the install. Returns
+  // only once storage is writable; the caller re-runs the vault-bind mutation after.
+  const ensureStorageGrant = async () => {
+    log('storage-grant', { state: 'requesting' })
+    process.stdout.write(
+      `\n[maxy-lite] Shared storage is needed for the vault at ${PATHS.vaultHost}.\n` +
+        `[maxy-lite] An Android dialog will appear — tap "Allow", then leave this running.\n`,
+    )
+    run('termux-setup-storage')
+    while (!storageAccessible()) {
+      await new Promise((resolve) => setTimeout(resolve, STORAGE_POLL_MS))
+    }
+    log('storage-grant', { state: 'granted' })
+  }
   const ctx = {
     run,
     runIn,
@@ -175,6 +210,9 @@ async function main() {
     runInStream,
     existsHost,
     mkdirHost,
+    storageAccessible,
+    interactive,
+    ensureStorageGrant,
     layPayload,
     installDeps,
     writeLauncher,

package/lib/orchestrate.mjs

@@ -29,10 +29,34 @@ function ensureOk(r) {
   return r
 }
 
-/** The Ubuntu rootfs path under the Termux prefix. */
-function rootfsPath() {
-  const prefix = process.env.PREFIX || '/data/data/com.termux/files/usr'
-  return `${prefix}/var/lib/proot-distro/installed-rootfs/${PATHS.distro}`
+/** The actionable error when the vault's shared-storage parent is not writable. */
+const STORAGE_PERMISSION_ERROR = 'storage-permission-required: run termux-setup-storage and grant access'
+
+/**
+ * Gate the vault-bind mutation on shared-storage access. The vault parent
+ * (`/storage/emulated/0`) is unwritable until Termux has been granted Android
+ * shared-storage permission, so `c.mkdirHost(vaultHost)` would otherwise fail with
+ * an opaque `Permission denied`. When access is missing we either drive the
+ * interactive grant (TTY present), which blocks until the permission lands, or
+ * fail fast with a clear, actionable message when no TTY can surface the dialog.
+ */
+async function ensureStorageAccessible(c) {
+  if (c.storageAccessible()) return
+  if (!c.interactive) throw new Error(STORAGE_PERMISSION_ERROR)
+  await c.ensureStorageGrant()
+}
+
+/**
+ * True when proot-distro can enter the distro — its own proof the rootfs is
+ * installed. A login that exits 0 means proot-distro resolved and entered the
+ * rootfs. The earlier guard reconstructed the rootfs path and `fs.existsSync`'d
+ * it, which disagreed with proot-distro on-device (present to proot-distro,
+ * absent to the path guess) and re-ran `install` into an "already exists"
+ * failure. Delegating to proot-distro's own exit code makes the guard agree
+ * with the install action by construction, so an installed distro skips.
+ */
+function distroInstalled(c) {
+  return c.runIn('true').code === 0
 }
 
 /** True when the glibc Node inside Ubuntu matches the pinned major. */
@@ -57,7 +81,7 @@ const STEPS = [
   },
   {
     name: 'ubuntu',
-    done: (c) => c.existsHost(rootfsPath()),
+    done: (c) => distroInstalled(c),
     run: async (c) => ensureOk(await c.runStream(`proot-distro install ${PATHS.distro}`)),
   },
   {
@@ -77,7 +101,8 @@ const STEPS = [
   {
     name: 'vault-bind',
     done: (c) => c.existsHost(PATHS.vaultHost),
-    run: (c) => {
+    run: async (c) => {
+      await ensureStorageAccessible(c)
       c.mkdirHost(PATHS.vaultHost)
       ensureOk(c.run(`proot-distro login ${PATHS.distro} --bind ${PATHS.vaultHost}:${PATHS.vaultGuest} -- test -d ${PATHS.vaultGuest}`))
     },

package/lib/paths.mjs

@@ -21,6 +21,25 @@ 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`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy-lite",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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": {