npm - handmux - Versions diffs - 0.29.0 → 0.29.2 - Mend

handmux 0.29.0 → 0.29.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/connectors/claude/index.js +45 -3
package/dist/hooks/handmux-notify.sh +12 -2
package/dist/hooks/handmux-write.cjs +4 -1
package/dist/package.json +13 -13
package/dist/public/assets/{index-D0tDAqO-.js → index-2ghkmGbT.js} +95 -95
package/dist/public/index.html +1 -1
package/dist/src/agent-runtime/bridge.js +63 -1
package/dist/src/agent-runtime/bridgeTypes.js +2 -0
package/dist/src/agent-runtime/runtime.js +1 -0
package/dist/src/agent-runtime/tmuxRuntime.js +27 -3
package/dist/src/agents/claudeNativeTail.js +19 -3
package/dist/src/agents/processIdentity.js +10 -1
package/dist/src/deviceAuth/http.js +9 -3
package/dist/src/push.js +5 -1
package/package.json +4 -4

package/dist/public/index.html CHANGED Viewed

@@ -48,7 +48,7 @@
       @keyframes bootDot { 0%,100% { opacity: .22; transform: translateY(0); } 40% { opacity: 1; transform: translateY(-3px); } }
       @media (prefers-reduced-motion: reduce) { .boot-glow, .boot-dots i { animation: none; opacity: .8; } }
     </style>
-    <script type="module" crossorigin src="/assets/index-D0tDAqO-.js"></script>
+    <script type="module" crossorigin src="/assets/index-2ghkmGbT.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BjnnFTLC.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-BjnnFTLC.css"></noscript>
   </head>
   <body>

package/dist/src/agent-runtime/bridge.js CHANGED Viewed

@@ -83,6 +83,9 @@ function channelKey(agentId, runId, name) {
 function consumerKey(agentId, name) {
     return `${agentId}\0${name}`;
 }
+// Retention sweep cadence. Reclaims are also attempted at construction (a restart is when the largest
+// dead set is present), so this only bounds growth during a long-lived server.
+const RECLAIM_INTERVAL_MS = 5 * 60_000;
 function mergeLimits(overrides) {
     const limits = { ...DEFAULT_BRIDGE_LIMITS, ...overrides };
     for (const [name, value] of Object.entries(limits)) {
@@ -198,9 +201,11 @@ export class LocalAgentBridge {
     #newRequestId;
     #now;
     #retryDelayMs;
+    #onReclaim;
     #writeTail = Promise.resolve();
+    #reclaimTimer;
     #closed = false;
-    constructor({ runs, adapterIds, store = new MemoryBridgeStateStore(), limits, newConnectionId = randomUUID, newRequestId = randomUUID, now = Date.now, retryDelayMs = 250, }) {
+    constructor({ runs, adapterIds, store = new MemoryBridgeStateStore(), limits, newConnectionId = randomUUID, newRequestId = randomUUID, now = Date.now, retryDelayMs = 250, onReclaim, }) {
         if (!runs || !Array.isArray(adapterIds) || adapterIds.length === 0) {
             throw new TypeError('LocalAgentBridge requires a run registry and static adapter ids');
         }
@@ -216,6 +221,7 @@ export class LocalAgentBridge {
         this.#newRequestId = newRequestId;
         this.#now = now;
         this.#retryDelayMs = Math.max(1, retryDelayMs);
+        this.#onReclaim = onReclaim;
         const persisted = parsePersistedState(this.#store.load());
         const spoolBytes = new Map();
         for (const channel of persisted.channels) {
@@ -244,9 +250,15 @@ export class LocalAgentBridge {
                 pumping: false,
                 pumpAgain: false,
                 retryTimer: undefined,
+                touchedAt: this.#now(),
                 durableWaiters: [],
             });
         }
+        // A restart is the natural point to drop channels whose runs died before it: nothing can attach to
+        // that run again, so their undelivered events are unreachable either way.
+        this.reclaimChannels();
+        this.#reclaimTimer = setInterval(() => this.reclaimChannels(), RECLAIM_INTERVAL_MS);
+        this.#reclaimTimer.unref?.();
     }
     connect(run) {
         this.#assertLive(run);
@@ -359,6 +371,10 @@ export class LocalAgentBridge {
         if (this.#closed)
             return;
         this.#closed = true;
+        if (this.#reclaimTimer) {
+            clearInterval(this.#reclaimTimer);
+            this.#reclaimTimer = undefined;
+        }
         for (const connection of this.#connections.values())
             connection.close();
         this.#connections.clear();
@@ -418,10 +434,12 @@ export class LocalAgentBridge {
                 pumping: false,
                 pumpAgain: false,
                 retryTimer: undefined,
+                touchedAt: this.#now(),
                 durableWaiters: [],
             };
             this.#channels.set(key, state);
         }
+        state.touchedAt = this.#now();
         return state;
     }
     async #withWrite(operation) {
@@ -442,6 +460,50 @@ export class LocalAgentBridge {
             channels: [...this.#channels.values()].map((state) => structuredClone(state.persisted)),
         });
     }
+    // Drops channels that can never be consumed again, so a reconnecting or flapping attachment cannot grow
+    // the bridge state without bound. A channel of a live run is never touched — it may reconnect and its
+    // undelivered events are still reachable. Returns what was dropped so a caller can log it.
+    reclaimChannels() {
+        const now = this.#now();
+        const dead = (state) => !state.subscription
+            && state.durableWaiters.length === 0 && state.live.length === 0
+            // The registry contract returns null for a run it no longer holds; treat any falsy result the same
+            // so a registry that omits the value cannot silently disable retention.
+            && !this.#runs.resolve(state.persisted.run);
+        let channels = 0;
+        let droppedEvents = 0;
+        const drop = (key, state) => {
+            if (state.retryTimer)
+                clearTimeout(state.retryTimer);
+            droppedEvents += state.persisted.durable.length;
+            this.#channels.delete(key);
+            channels += 1;
+        };
+        for (const [key, state] of [...this.#channels]) {
+            if (!dead(state))
+                continue;
+            // Drained ⇒ nothing can be lost. Still holding events ⇒ wait out the retention window first, so a
+            // transient gap in run bookkeeping cannot drop a notification that is still deliverable.
+            if (state.persisted.durable.length > 0 && now - state.touchedAt < this.limits.channelRetentionMs)
+                continue;
+            drop(key, state);
+        }
+        // Hard ceiling: retention must bound memory even while every dead channel is inside its window.
+        if (this.#channels.size > this.limits.maxChannels) {
+            const oldest = [...this.#channels].filter(([, state]) => dead(state))
+                .sort((left, right) => left[1].touchedAt - right[1].touchedAt);
+            for (const [key, state] of oldest) {
+                if (this.#channels.size <= this.limits.maxChannels)
+                    break;
+                drop(key, state);
+            }
+        }
+        if (channels > 0) {
+            this.#save();
+            this.#onReclaim?.({ channels, droppedEvents });
+        }
+        return { channels, droppedEvents };
+    }
     #nextSequence(state) {
         if (state.persisted.highWatermark >= Number.MAX_SAFE_INTEGER) {
             throw new BridgeContractError('Bridge channel sequence is exhausted');

package/dist/src/agent-runtime/bridgeTypes.js CHANGED Viewed

@@ -10,4 +10,6 @@ export const DEFAULT_BRIDGE_LIMITS = Object.freeze({
     maxRequestTimeoutMs: 5 * 60_000,
     sustainedEventsPerSecond: 200,
     burstEvents: 500,
+    maxChannels: 2_000,
+    channelRetentionMs: 24 * 60 * 60_000,
 });

package/dist/src/agent-runtime/runtime.js CHANGED Viewed

@@ -219,6 +219,7 @@ export class AgentRuntime {
                 runs: this.runs,
                 adapterIds,
                 store: new FileBridgeStateStore(bridgeStateFile),
+                onReclaim: (result) => logger.info('Reclaimed Bridge channels for Agent runs that are no longer live', result),
                 ...(newBridgeConnectionId === undefined ? {} : { newConnectionId: newBridgeConnectionId }),
             }),
         });

package/dist/src/agent-runtime/tmuxRuntime.js CHANGED Viewed

@@ -1,3 +1,4 @@
+import { promises as fsp } from 'node:fs';
 import { executablePath } from '../agents/processIdentity.js';
 import { defaultRun, etimeToMs, normTty } from '../agents/scanUtils.js';
 function pane(value) {
@@ -124,6 +125,30 @@ function foregroundLeaf(rows, tty, paneCommand) {
         .sort((first, second) => second.elapsedMs - first.elapsedMs
         || depth(first) - depth(second) || second.pid - first.pid)[0] ?? null;
 }
+// Process start time, in a form that only depends on the process itself.
+//
+// `ps -o lstart` is a wall-clock derivation (boot time + start ticks). A host that steps the guest clock
+// (WSL2 syncs from Hyper-V, moving the guest forward every few tens of seconds) therefore makes the same
+// live process report a *different* start time after every step, which every identity comparison reads as
+// "the process was replaced". Linux exposes the raw start tick instead, and macOS does not step its clock
+// this way, so it keeps lstart. The Hook records the same value per platform — keep the two in step
+// (server/hooks/handmux-notify.sh).
+// Exported so the platform split can be unit-tested; callers use inspectForeground.
+export async function processStartedAt(run, pid) {
+    if (process.platform === 'linux') {
+        try {
+            const stat = await fsp.readFile(`/proc/${pid}/stat`, 'utf8');
+            // comm may contain spaces and parentheses: start from the last ')' to reach field 3 (state).
+            const fields = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+            const startTicks = Number(fields[19]); // field 22 of /proc/<pid>/stat
+            if (Number.isSafeInteger(startTicks) && startTicks >= 0)
+                return startTicks;
+        }
+        catch { /* fall back to the portable lstart read */ }
+    }
+    const parsed = Date.parse(String(await run('ps', ['-p', String(pid), '-o', 'lstart='])).trim());
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
     return {
         async inspectForeground(pane) {
@@ -137,12 +162,11 @@ export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
             const row = foregroundLeaf(foregroundRows(output), tty, pane.currentCommand);
             if (!row)
                 return null;
-            const rawStartedAt = String(await run('ps', ['-p', String(row.pid), '-o', 'lstart='])).trim();
-            const parsedStartedAt = Date.parse(rawStartedAt);
+            const startedAt = await processStartedAt(run, row.pid);
             const executable = await executablePath(run, row.pid);
             return {
                 pid: row.pid,
-                ...(Number.isFinite(parsedStartedAt) ? { startedAt: parsedStartedAt } : {}),
+                ...(startedAt === undefined ? {} : { startedAt }),
                 tty: pane.tty ?? `/dev/${tty}`,
                 ...(executable ? { executable } : {}),
                 ...(row.command ? { commandLine: row.command } : {}),

package/dist/src/agents/claudeNativeTail.js CHANGED Viewed

@@ -6,6 +6,16 @@ const record = (value) => value !== null && typeof value === 'object' && !Array.
 const METADATA = new Set(['last-prompt', 'ai-title', 'mode', 'permission-mode', 'file-history-snapshot']);
 const MAX_BYTES = 65536;
 const MAX_SESSIONS = 128;
+// Claude's registry records the process start in the same platform-shaped form we read: a raw procfs tick
+// on Linux, an lstart string on macOS (see processStartedAt in tmuxRuntime.ts). Compare like with like —
+// assuming a date string made Linux native status permanently unknown (`Date.parse('473349 UTC')` is NaN).
+function sameProcessStart(recorded, observed) {
+    if (typeof recorded !== 'string' || observed === undefined)
+        return false;
+    return /^\d+$/.test(recorded)
+        ? Number(recorded) === observed
+        : Date.parse(`${recorded} UTC`) === observed;
+}
 function interruption(rows, sessionId, promptId, after, now) {
     let duration;
     for (let index = rows.length - 1; index >= 0; index--) {
@@ -97,8 +107,8 @@ export class ClaudeNativeTailReader {
             this.#statuses.delete(registry);
             return unknown();
         }
-        if (!row || row.pid !== process.pid || row.sessionId !== payload.session_id || row.kind !== 'interactive'
-            || typeof row.procStart !== 'string' || Date.parse(`${row.procStart} UTC`) !== process.startedAt)
+        if (!row || row.pid !== process.pid || row.sessionId !== payload.session_id
+            || row.kind !== 'interactive' || !sameProcessStart(row.procStart, process.startedAt))
             return unknown();
         this.#nativeProcesses.add(identity);
         while (this.#nativeProcesses.size > MAX_SESSIONS)
@@ -114,7 +124,13 @@ export class ClaudeNativeTailReader {
         if (typeof row.statusUpdatedAt === 'number' && row.statusUpdatedAt <= after) {
             return { ...native, settled: null, localCommand: null };
         }
-        if (typeof row.statusUpdatedAt !== 'number' || row.statusUpdatedAt < process.startedAt || row.statusUpdatedAt > now
+        // The status is only bounded from above here. A "newer than the process start" lower bound would need
+        // both sides in the same clock domain, which only holds where the start value is epoch-shaped (macOS);
+        // on Linux it is a raw tick. pid + session + start token already identify the row.
+        const startedEpoch = typeof process.startedAt === 'number' && process.startedAt > 1e12
+            ? process.startedAt : undefined;
+        if (typeof row.statusUpdatedAt !== 'number' || row.statusUpdatedAt > now
+            || (startedEpoch !== undefined && row.statusUpdatedAt < startedEpoch)
             || (row.status === 'idle' && (!native.transcriptComplete || row.statusUpdatedAt <= after || row.statusUpdatedAt < (native.latestNativeAt ?? 0)))
             || !['idle', 'busy', 'waiting'].includes(String(row.status)))
             return unknown();

package/dist/src/agents/processIdentity.js CHANGED Viewed

@@ -5,7 +5,13 @@ const SUCCESS_TTL_MS = 30_000;
 const FAILURE_TTL_MS = 3_000;
 // Real executable path of a pid. lsof resolves launch symlinks on macOS; /proc is the cheap Linux path.
 // A transient lsof failure is inconclusive, not a negative identity verdict that should escape the call.
-export async function executablePath(run, pid) {
+// Linux appends " (deleted)" once the file is unlinked while the image stays mapped: Claude's auto-updater
+// prunes the old version file under a running session, and that session keeps working. The marker must not
+// reach a basename comparison — it would turn an unambiguous identity into a mismatch and silently drop
+// the pane until Claude restarts. Every consumer reads the path through here, so normalize at the exit.
+const DELETED_MARKER_RE = / \(deleted\)$/;
+export const stripDeletedMarker = (file) => file.replace(DELETED_MARKER_RE, '');
+async function rawExecutablePath(run, pid) {
     if (process.platform === 'linux') {
         try {
             return await fsp.readlink(`/proc/${pid}/exe`);
@@ -28,6 +34,9 @@ export async function executablePath(run, pid) {
     }
     return '';
 }
+export async function executablePath(run, pid) {
+    return stripDeletedMarker(await rawExecutablePath(run, pid));
+}
 function parseForegroundProcesses(out) {
     const rows = [];
     for (const line of String(out).split('\n')) {

package/dist/src/deviceAuth/http.js CHANGED Viewed

@@ -14,7 +14,13 @@ function browserSummary(ua) {
     const os = /(?:iPhone|iPad|iPod)/.test(ua) ? 'iOS' : /Android/.test(ua) ? 'Android' : /Windows/.test(ua) ? 'Windows' : /Macintosh|Mac OS X/.test(ua) ? 'macOS' : /Linux/.test(ua) ? 'Linux' : '';
     return os ? `${browser} · ${os}` : browser;
 }
-export function createDeviceAuthRouter({ service, resolveOrigin, resolvePublicUrl, previewDomain }) {
+export function createDeviceAuthRouter({ service, resolveOrigin, resolvePublicUrl, previewDomain, buckets: bucketOptions }) {
+    const maxRequests = bucketOptions?.maxRequests ?? 600;
+    const maxCreates = bucketOptions?.maxCreates ?? 20;
+    const windowMs = bucketOptions?.windowMs ?? 60_000;
+    if (![maxRequests, maxCreates, windowMs].every((value) => Number.isSafeInteger(value) && value > 0)) {
+        throw new TypeError('Device auth bucket limits must be positive integers');
+    }
     const router = Router();
     const advertisedOrigin = () => {
         const value = resolvePublicUrl?.();
@@ -84,7 +90,7 @@ export function createDeviceAuthRouter({ service, resolveOrigin, resolvePublicUr
         const token = principal && service.isTokenPrincipal(principal);
         const buckets = !principal ? anonymousBuckets : token ? tokenBuckets : authenticatedBuckets;
         for (const [key, value] of buckets)
-            if (now - value.at >= 60_000)
+            if (now - value.at >= windowMs)
                 buckets.delete(key);
         const key = !principal ? req.socket.remoteAddress ?? 'unknown'
             : token ? `${principal.sessionId}:${req.socket.remoteAddress ?? 'unknown'}:${(req.get('user-agent') ?? '').slice(0, 200)}`
@@ -101,7 +107,7 @@ export function createDeviceAuthRouter({ service, resolveOrigin, resolvePublicUr
         bucket.requests++;
         if (req.method === 'POST' && req.path === '/pairing')
             bucket.creates++;
-        if (bucket.requests > 600 || bucket.creates > 20) {
+        if (bucket.requests > maxRequests || bucket.creates > maxCreates) {
             res.set('Retry-After', '60').status(429).json({ error: 'AUTH_RATE_LIMIT', message: 'Wait one minute and try again' });
             return;
         }

package/dist/src/push.js CHANGED Viewed

@@ -75,7 +75,11 @@ let subs = load();
 let deviceAuthorization = null;
 const allowed = (rec) => {
     try {
-        return deviceAuthorization ? (!rec.authDeviceId || deviceAuthorization(rec.authDeviceId)) : !rec.authDeviceId;
+        // Once device authorization is active, legacy unbound subscriptions are no
+        // longer eligible. They have no device identity that can be authorized.
+        return deviceAuthorization
+            ? Boolean(rec.authDeviceId && deviceAuthorization(rec.authDeviceId))
+            : !rec.authDeviceId;
     }
     catch {
         return false;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "handmux",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "A mobile vibe-coding cockpit — built on tmux: drive your live session, Claude Code / Codex — anything a terminal can run — from your phone.",
   "type": "module",
   "license": "AGPL-3.0-only",
@@ -75,13 +75,13 @@
     "vitest": "^2.0.0"
   },
   "whatsNew": [
+    {"version":"0.29.2","date":"2026-09-18","zh":"修复 Linux 下 Claude 事件上报的兼容问题","en":"Compatibility fix for Claude event reporting on Linux"},
+    {"version":"0.29.1","date":"2026-09-18","zh":"修复 Claude 对话入口丢失 · 长时间运行不再变卡","en":"Fix lost Claude chat entries · no slowdown after long runs"},
     {"version":"0.29.0","date":"2026-09-16","zh":"可信设备与可信地址保护","en":"Trusted device and address protection"},
     {"version":"0.28.0","date":"2026-09-11","zh":"Claude 对话更可靠 · 工具图片预览","en":"More reliable Claude chat · tool image previews"},
     {"version":"0.27.2","date":"2026-09-08","zh":"修复多标签页偶发鉴权弹窗","en":"Fix intermittent authentication prompts across tabs"},
     {"version":"0.27.1","date":"2026-09-08","zh":"腾讯语音 · 终端光标修复 · Codex 对话恢复","en":"Tencent voice · terminal cursor fixes · Codex chat recovery"},
     {"version":"0.27.0","date":"2026-09-05","zh":"腾讯语音输入 · 终端输入更准确","en":"Tencent voice input · more accurate terminal typing"},
-    {"version":"0.26.0","date":"2026-09-04","zh":"对话精细复制 · Pi 上下文状态","en":"Precise chat copy · Pi context status"},
-    {"version":"0.25.2","date":"2026-09-02","zh":"修复 Agent 对话断流、排队与工具路径","en":"Fixed Agent chat streams, queues, and tool paths"},
-    {"version":"0.25.1","date":"2026-09-02","zh":"修复 Codex 幽灵任务与对话空白","en":"Fixed Codex ghost tasks and blank chats"}
+    {"version":"0.26.0","date":"2026-09-04","zh":"对话精细复制 · Pi 上下文状态","en":"Precise chat copy · Pi context status"}
   ]
 }