@rubytech/create-maxy-lite 0.1.13 → 0.1.15

package/lib/paths.mjs

@@ -183,7 +183,14 @@ export function launcherScript({
   port = PATHS.webchatPort,
   distro = PATHS.distro,
 } = {}) {
-  const inner = `cd ${webchatDir} && ${webchatRunEnv({ vaultGuest, port })} exec node server.mjs`
+  // Kill any prior relay before starting so `maxy-lite` always runs the freshly
+  // installed server.mjs, never a stale process still holding the port (which made
+  // a new build appear to "have no effect"). The relay writes its pid to
+  // <vault>/.maxy-lite/relay.pid; kill via the bash builtin (no external tools),
+  // and a best-effort pkill catches a relay started before pid-file support. The
+  // relay's own EADDRINUSE handler makes any remaining conflict loud.
+  const killPrior = `P=$(cat ${vaultGuest}/.maxy-lite/relay.pid 2>/dev/null); [ -n "$P" ] && kill "$P" 2>/dev/null; pkill -f "node server.mjs" 2>/dev/null; sleep 1`
+  const inner = `${killPrior}; 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

package/package.json

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

package/payload/webchat/server.mjs

@@ -34,8 +34,10 @@ const CLAUDE_BIN = process.env.LITE_CLAUDE_BIN || 'claude'
 const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects')
 const STATE_DIR = process.env.LITE_STATE_DIR || path.join(AGENT_HOME, '.maxy-lite')
 const SESSION_FILE = path.join(STATE_DIR, 'session-id')
+const PID_FILE = path.join(STATE_DIR, 'relay.pid') // so the launcher can kill a prior relay before starting a fresh one
 const TAIL_MS = 250 // JSONL poll interval
 const QUIET_MS = 1500 // silence that ends a turn for op=done
+const NO_REPLY_MS = 8000 // a turn with NO transcript growth this long = swallowed; surface why
 
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
 
@@ -89,9 +91,26 @@ const child = pty.spawn(CLAUDE_BIN, args, {
   cwd: AGENT_HOME,
   env: process.env,
 })
-// The pty is input-only for our purposes; draining stdout prevents backpressure
-// from stalling claude. Render comes from the JSONL, never these bytes.
-child.onData(() => {})
+// Render comes from the JSONL, not these bytes — but capture a bounded, sanitised
+// sample of claude's own pty output so a swallow is diagnosable. It reveals a
+// first-run trust/onboarding prompt eating the input, an error screen, or silence
+// (input never submitted). Draining also prevents backpressure stalling claude.
+let ptyBytes = 0
+let turnPtyBase = 0
+let ptySample = ''
+const sanitizePty = (s) =>
+  s
+    .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '')
+    .replace(/\x1b[()][AB0]/g, '')
+    .replace(/[\r\n]+/g, ' ')
+    .replace(/[^\x20-\x7e]/g, '')
+child.onData((d) => {
+  ptyBytes += d.length
+  ptySample = (ptySample + sanitizePty(d)).slice(-300) // most recent 300 printable chars
+})
+// Log the fresh claude screen once it has settled — a trust/onboarding prompt here
+// explains a swallowed first message before any turn is even sent.
+setTimeout(() => log('output', { turn: 0, ptyBytes, head: ptySample.slice(0, 300) }), 3000)
 child.onExit(({ exitCode }) => log('child-exit', { exitCode }))
 log('spawn', { turn: 0, pty: true, pid: child.pid })
 
@@ -162,9 +181,26 @@ setInterval(tail, TAIL_MS)
 // Gated on turnSawGrowth so a slow first JSONL write (cold start, discovery
 // latency) cannot mark the turn done before any reply has rendered.
 setInterval(() => {
-  if (turnActive && turnSawGrowth && Date.now() - lastActivity > QUIET_MS) {
+  if (!turnActive) return
+  if (turnSawGrowth && Date.now() - lastActivity > QUIET_MS) {
     turnActive = false
     log('done', { turn, ranMs: Date.now() - turnStart })
+  } else if (!turnSawGrowth && Date.now() - turnStart > NO_REPLY_MS) {
+    // No transcript growth after the input → the message was swallowed. Surface the
+    // two facts that locate it: what claude actually emitted to its pty, and whether
+    // its transcript was even found (and if not, what dirs exist vs the one wanted).
+    turnActive = false
+    log('output', { turn, ptyBytes: ptyBytes - turnPtyBase, head: ptySample.slice(0, 300) })
+    if (!transcriptPath) {
+      let dirs = []
+      try {
+        dirs = fs.readdirSync(PROJECTS_DIR)
+      } catch {
+        /* PROJECTS_DIR absent */
+      }
+      log('jsonl-missing', { want: `${sessionId}.jsonl`, projectsDir: PROJECTS_DIR, dirs: `[${dirs.join(',')}]` })
+    }
+    log('done', { turn, ok: false, reason: 'no-transcript-growth', ranMs: Date.now() - turnStart })
   }
 }, 500)
 
@@ -180,6 +216,8 @@ function submitToAgent(text) {
   turnSawGrowth = false
   turnStart = Date.now()
   lastActivity = Date.now()
+  turnPtyBase = ptyBytes // baseline so op=output reports bytes claude emitted THIS turn
+  ptySample = ''
   log('inbound', { turn, chars: text.length })
   child.write(ptyLine(text))
   log('spawn', { turn, pty: true, pid: child.pid })
@@ -224,6 +262,22 @@ wss.on('connection', (ws) => {
   })
 })
 
+// A stale relay still holding the port is the usual cause of "new build installed
+// but old code serving". Make it loud instead of a silent stale-serve.
+server.on('error', (e) => {
+  log('listen-error', { code: e.code, port: PORT })
+  process.exit(1)
+})
 server.listen(PORT, '127.0.0.1', () => {
+  // Record our pid so the next launch can kill this relay and take over cleanly,
+  // and emit a build marker: op=relay-start proves THIS server.mjs (not a stale
+  // one) is the live process.
+  try {
+    fs.mkdirSync(STATE_DIR, { recursive: true })
+    fs.writeFileSync(PID_FILE, String(process.pid))
+  } catch {
+    /* pid file is best-effort */
+  }
+  log('relay-start', { pid: process.pid, port: PORT })
   log('listening', { port: PORT, sessionId, home: AGENT_HOME })
 })