handmux 0.17.3 → 0.17.4

package/public/index.html

@@ -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-Ddagv-Lc.js"></script>
+    <script type="module" crossorigin src="/assets/index-BfJTQWOA.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BT03K2MQ.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-BT03K2MQ.css"></noscript>
   </head>
   <body>

package/src/claudeEvents.js

@@ -324,5 +324,14 @@ export function createClaudeEvents({ commands, push, file = DEFAULT_STATE_FILE,
     return { sessionId, transcriptPath, cwd };
   }
 
-  return { getStates, start, stop, paneSession };
+  // Agent identity is needed independently of session metadata: a Codex pane may not have a Claude-style
+  // transcript path, but the current Claude-only chat lens must still fail closed instead of cwd-falling
+  // back to an unrelated Claude jsonl. Untagged legacy hook rows are Claude.
+  function paneAgent(pane) {
+    const rec = readStateFile(file)[pane];
+    if (!rec || typeof rec !== 'object') return null;
+    return typeof rec.agent === 'string' && rec.agent ? rec.agent : 'claude';
+  }
+
+  return { getStates, start, stop, paneSession, paneAgent };
 }

package/src/cli/pushCmd.js

@@ -3,6 +3,7 @@
 // Scope is mutually exclusive: --device (by key) or --session, else all. Pure parse + injectable
 // runner so it unit-tests without spawning or real fetch.
 import { readState } from './state.js';
+import { sanitizeNotificationUrl } from '../urlPolicy.js';
 
 const collect = (acc, v) => acc.concat(String(v).split(',').map((s) => s.trim()).filter(Boolean));
 
@@ -23,11 +24,13 @@ export function parsePushArgs(argv) {
   const [title, body] = positional;
   if (!title || !body) return { error: 'usage: handmux push <title> <body> [--session X]... [--device K]... [--tag T] [--url U]' };
   if (sessions.length && devices.length) return { error: 'use --session or --device, not both' };
+  const safeUrl = url == null ? null : sanitizeNotificationUrl(url);
+  if (url != null && !safeUrl) return { error: '--url must be an http(s) URL or a relative path' };
   const out = { title, body };
   if (sessions.length) out.sessions = sessions;
   if (devices.length) out.devices = devices;
   if (tag) out.tag = tag;
-  if (url) out.url = url;
+  if (safeUrl) out.url = safeUrl;
   return out;
 }
 

package/src/notifications.js

@@ -8,6 +8,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import crypto from 'node:crypto';
 import { readJsonArray, writeJsonAtomic } from './jsonStore.js';
+import { sanitizeNotificationUrl } from './urlPolicy.js';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const DIR = process.env.NOTIF_DIR || path.resolve(here, '../data/notifications');
@@ -24,7 +25,8 @@ const load = (file) => readJsonArray(file).filter((n) => n && typeof n.title ===
 export function record(pushKeys, { title, body, tag, url } = {}) {
   const rec = { id: genId(), ts: Date.now(), title: String(title ?? ''), body: String(body ?? '') };
   if (tag) rec.tag = String(tag);
-  if (url) rec.url = String(url);
+  const safeUrl = sanitizeNotificationUrl(url);
+  if (safeUrl) rec.url = safeUrl;
   for (const key of pushKeys || []) {
     const file = fileFor(key);
     if (!file) continue;

package/src/previewServer.js

@@ -5,6 +5,8 @@
 // Also handles dynamic preview: Host-based dispatch to loopback ports (HTTP + WS upgrade).
 import net from 'node:net';
 import http from 'node:http';
+import https from 'node:https';
+import tls from 'node:tls';
 import express from 'express';
 import { tokenEquals } from './auth.js';
 import { safePreviewName } from './previews.js';
@@ -57,7 +59,15 @@ function cookieScope(domain) {
 // Resolve the on-disk file for a request path under a preview: '' or '<dir>/' → its index.html.
 function fileFor(rest) { return (!rest || rest.endsWith('/')) ? `${rest}index.html` : rest; }
 
-export function createPreview({ previews, token, domain = null }) {
+export function createPreview({
+  previews,
+  token,
+  domain = null,
+  httpRequest = http.request,
+  httpsRequest = https.request,
+  netConnect = net.connect,
+  tlsConnect = tls.connect,
+}) {
   const router = express.Router();
   const cookieDomain = cookieScope(domain);
 
@@ -117,9 +127,16 @@ export function createPreview({ previews, token, domain = null }) {
   // its own root, so path/method/headers/body forward as-is. `host` is the loopback family the app was
   // found on at register time ('127.0.0.1' or '::1'); the Host header stays 127.0.0.1:<port> so a dev
   // server's host check (e.g. Vite, whose allowedHosts include localhost/127.0.0.1) is satisfied.
-  function proxyHttp(port, host, req, res) {
+  function proxyHttp(port, host, protocol, req, res) {
     const headers = { ...req.headers, host: `127.0.0.1:${port}` };
-    const up = http.request({ host: host || '127.0.0.1', port, method: req.method, path: req.url, headers }, (upRes) => {
+    const secure = protocol === 'https';
+    const request = secure ? httpsRequest : httpRequest;
+    const options = { host: host || '127.0.0.1', port, method: req.method, path: req.url, headers };
+    // Local HTTPS dev servers commonly use a self-signed certificate. The connection target is constrained
+    // to loopback by registration/probing, so accepting that certificate does not expand trust to a network
+    // host. SNI stays localhost because that is what development certificates are normally issued for.
+    if (secure) Object.assign(options, { servername: 'localhost', rejectUnauthorized: false });
+    const up = request(options, (upRes) => {
       res.writeHead(upRes.statusCode, upRes.headers);
       upRes.on('error', () => res.destroy()); // mid-stream upstream reset (after headers) → tear down the client socket
       upRes.pipe(res);
@@ -147,7 +164,7 @@ export function createPreview({ previews, token, domain = null }) {
     if (state === 'missing') return res.status(404).type('html').send('<!doctype html><meta charset="utf-8"><h1>预览不存在</h1>');
     if (state === 'expired') return res.status(410).type('html').send('<!doctype html><meta charset="utf-8"><h1>预览已过期</h1><p>请回到 app 重新启动预览。</p>');
     if (entry.kind !== 'dynamic') return res.status(404).end(); // a static name reached via subdomain — not served here
-    proxyHttp(entry.port, entry.host, req, res);
+    proxyHttp(entry.port, entry.host, entry.protocol, req, res);
   }
 
   // WebSocket (and any raw Upgrade) for a dynamic preview: same cookie auth, then a bare TCP pipe to
@@ -165,7 +182,13 @@ export function createPreview({ previews, token, domain = null }) {
     if (!credOk({ query, headers: req.headers }, token)) return socket.destroy();
     const { state, entry } = previews.get(name);
     if (state !== 'active' || entry.kind !== 'dynamic') return socket.destroy();
-    const up = net.connect(entry.port, entry.host || '127.0.0.1', () => {
+    const secure = entry.protocol === 'https';
+    const options = { port: entry.port, host: entry.host || '127.0.0.1' };
+    if (secure) Object.assign(options, {
+      servername: 'localhost', rejectUnauthorized: false, ALPNProtocols: ['http/1.1'],
+    });
+    const connect = secure ? tlsConnect : netConnect;
+    const up = connect(options, () => {
       const fwd = { ...req.headers, host: `127.0.0.1:${entry.port}` };
       up.write(`GET ${req.url} HTTP/1.1\r\n`);
       for (const [k, v] of Object.entries(fwd)) up.write(`${k}: ${v}\r\n`);

package/src/previews.js

@@ -69,16 +69,17 @@ export function createPreviews({
     return { name: entry.name, kind: entry.kind, expiresAt: entry.expiresAt };
   };
 
-  async function register({ name, dir, port }) {
+  async function register({ name, dir, port, protocol = 'http' }) {
     const nm = safePreviewName(name);
     if (!nm) return { error: 'bad name', status: 400 };
     if (port !== undefined && port !== null && port !== '') {
       if (!dynamicEnabled) return { error: 'dynamic disabled', status: 400 };
+      if (protocol !== 'http' && protocol !== 'https') return { error: 'bad protocol', status: 400 };
       const p = Number(port);
       if (!Number.isInteger(p) || p < 1 || p > 65535) return { error: 'bad port', status: 400 };
       const host = await probePort(p); // '127.0.0.1' | '::1' | null
       if (!host) return { error: 'port not listening', status: 400 };
-      return upsert({ name: nm, kind: 'dynamic', port: p, host });
+      return upsert({ name: nm, kind: 'dynamic', port: p, host, protocol });
     }
     if (typeof dir !== 'string' || dir[0] !== '/') return { error: 'not absolute', status: 400 };
     let real;
@@ -94,14 +95,17 @@ export function createPreviews({
     const entry = entries.find((e) => e && e.name === name);
     if (!entry) return { state: 'missing' };
     if (entry.expiresAt <= now()) { entries = entries.filter((e) => e.name !== name); flush(); return { state: 'expired' }; }
-    return { state: 'active', entry: { kind: 'static', ...entry } }; // legacy rows (no kind) → static
+    const normalized = entry.kind === 'dynamic'
+      ? { ...entry, kind: 'dynamic', protocol: entry.protocol === 'https' ? 'https' : 'http' }
+      : { kind: 'static', ...entry }; // legacy rows (no kind) → static
+    return { state: 'active', entry: normalized };
   }
 
   function list() {
     const active = entries.filter((e) => e && e.expiresAt > now());
     if (active.length !== entries.length) { entries = active; flush(); }
     return active.map((e) => (e.kind === 'dynamic'
-      ? { name: e.name, kind: 'dynamic', port: e.port, expiresAt: e.expiresAt }
+      ? { name: e.name, kind: 'dynamic', port: e.port, protocol: e.protocol === 'https' ? 'https' : 'http', expiresAt: e.expiresAt }
       : { name: e.name, kind: 'static', dir: e.dir, expiresAt: e.expiresAt }));
   }
 

package/src/routes/previews.js

@@ -10,12 +10,14 @@ export function previewRoutes({ previews, previewDomain, token }) {
   // dynamic reverse-proxy reachable at https://<name>.<DOMAIN>/ (only when previewDomain is set).
   r.post('/previews', async (req, res, next) => {
     if (!previews) return res.status(503).json({ error: 'previews disabled' });
-    const { name, dir, port } = req.body || {};
+    const { name, dir, port, protocol } = req.body || {};
     if (typeof name !== 'string' || !name) return res.status(400).json({ error: 'bad request' });
     const hasPort = port !== undefined && port !== null && port !== '';
     if (!hasPort && (typeof dir !== 'string' || !dir)) return res.status(400).json({ error: 'bad request' });
     try {
-      const out = await previews.register(hasPort ? { name, port } : { name, dir });
+      const dynamic = { name, port };
+      if (protocol !== undefined) dynamic.protocol = protocol;
+      const out = await previews.register(hasPort ? dynamic : { name, dir });
       if (out.error) return res.status(out.status).json({ error: out.error });
       const url = out.kind === 'dynamic'
         ? `https://${encodeURIComponent(out.name)}.${previewDomain}/?token=${encodeURIComponent(token)}`

package/src/routes/push.js

@@ -1,6 +1,7 @@
 // Web Push routes: hand the client the VAPID key, store/update/remove a browser PushSubscription, and
 // the local script-push send entry. The push module owns the delivery contract (TTL/topic/prune).
 import express from 'express';
+import { sanitizeNotificationUrl } from '../urlPolicy.js';
 
 export function pushRoutes({ push, notifications }) {
   const r = express.Router();
@@ -55,6 +56,8 @@ export function pushRoutes({ push, notifications }) {
     const { sessions, devices, title, body, tag, url } = req.body || {};
     if (typeof title !== 'string' || !title.trim()) return res.status(400).json({ error: 'title required' });
     if (typeof body !== 'string' || !body.trim()) return res.status(400).json({ error: 'body required' });
+    const safeUrl = url == null ? null : sanitizeNotificationUrl(url);
+    if (url != null && !safeUrl) return res.status(400).json({ error: 'url must be http(s) or relative' });
     const hasSessions = Array.isArray(sessions) && sessions.length > 0;
     const hasDevices = Array.isArray(devices) && devices.length > 0;
     if (hasSessions && hasDevices) return res.status(400).json({ error: 'use --session or --device, not both' });
@@ -66,7 +69,7 @@ export function pushRoutes({ push, notifications }) {
     // is stored on the record (surfaced in the detail), NOT used as the tap target.
     if (notifications) {
       const targetKeys = push.resolveTargetKeys({ devices: hasDevices ? devices : null, sessions: hasSessions ? sessions : null });
-      const rec = notifications.record(targetKeys, { title, body, tag: payload.tag, url });
+      const rec = notifications.record(targetKeys, { title, body, tag: payload.tag, url: safeUrl });
       payload.data = { inboxId: rec.id };
     }
     try {

package/src/routes/transcript.js

@@ -23,11 +23,24 @@ import { readClaudeContext } from '../usage.js';
 export function transcriptRoutes({ commands, claudeEvents }) {
   const r = express.Router();
 
+  // These three endpoints are one Claude-specific lens surface. Gate them together so a future endpoint
+  // cannot accidentally skip the invariant: explicit non-Claude requests and panes already bound to a
+  // non-Claude hook record are rejected before any cwd→newest-Claude-session fallback or screen scraping.
+  r.use(['/pending-prompt', '/context', '/transcript'], (req, res, next) => {
+    const pane = req.query.pane;
+    if (!isPaneId(pane)) return res.status(400).json({ error: 'bad pane id' });
+    const requested = req.query.agent;
+    const bound = claudeEvents && claudeEvents.paneAgent ? claudeEvents.paneAgent(pane) : null;
+    if ((requested != null && requested !== '' && requested !== 'claude') || (bound && bound !== 'claude')) {
+      return res.status(409).json({ error: 'chat lens unsupported for this agent' });
+    }
+    next();
+  });
+
   // The pending interactive PROMPT on the pane's screen — an AskUserQuestion menu or a tool-permission
   // menu — scraped from `capture-pane` (its options are NOT in the .jsonl while pending; see pendingPrompt.js).
   // Returns { prompt: {kind,title,options,cursor} | null }. Polled by the 对话 lens only while a gate is up.
   r.get('/pending-prompt', async (req, res, next) => {
-    if (!isPaneId(req.query.pane)) return res.status(400).json({ error: 'bad pane id' });
     try {
       const text = await commands.capturePlain(req.query.pane);
       return res.json({ prompt: parsePendingPrompt(text) });
@@ -39,7 +52,6 @@ export function transcriptRoutes({ commands, claudeEvents }) {
   // { model, usedPercent } (either may be null: capturer not opted in / session hasn't rendered / no hooks).
   // The 对话 composer polls this to show a small "模型 · 24%" chip. Best-effort: never 500 on a missing file.
   r.get('/context', (req, res, next) => {
-    if (!isPaneId(req.query.pane)) return res.status(400).json({ error: 'bad pane id' });
     try {
       const hooked = claudeEvents && claudeEvents.paneSession ? claudeEvents.paneSession(req.query.pane) : null;
       const sid = hooked && (hooked.sessionId || (hooked.transcriptPath ? path.basename(hooked.transcriptPath).replace(/\.jsonl$/, '') : null));
@@ -49,7 +61,6 @@ export function transcriptRoutes({ commands, claudeEvents }) {
   });
 
   r.get('/transcript', async (req, res, next) => {
-    if (!isPaneId(req.query.pane)) return res.status(400).json({ error: 'bad pane id' });
     const limit = Math.min(Math.max(Number(req.query.limit) || 10, 1), 100);
     const before = req.query.before != null && req.query.before !== '' ? Number(req.query.before) : null;
     try {

package/src/urlPolicy.js

@@ -0,0 +1,14 @@
+// Notification links are user-supplied by `handmux push --url`. Keep relative in-app links, but reject
+// executable/non-web schemes (javascript:, data:, file:, …) before they reach storage or an <a href>.
+export function sanitizeNotificationUrl(value) {
+  if (typeof value !== 'string') return null;
+  const raw = value.trim();
+  if (!raw) return null;
+  try {
+    const parsed = new URL(raw, 'https://handmux.invalid/');
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}