@rubytech/create-maxy-lite 0.1.1 → 0.1.2

package/index.mjs

@@ -82,6 +82,25 @@ const appHostPath = `${rootfs}${PATHS.appDir}` // appDir is absolute inside the
 const existsHost = (p) => fs.existsSync(p)
 const mkdirHost = (p) => fs.mkdirSync(p, { recursive: true })
 
+// ---- 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
+
 /** Copy the bundled app payload into the Ubuntu rootfs (idempotent overwrite). */
 const layPayload = () => {
   fs.mkdirSync(appHostPath, { recursive: true })
@@ -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/package.json

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