hop2 0.11.13 → 0.11.14

package/hop

@@ -224,6 +224,281 @@ function validateConfigDir() {
 validateConfigDir();
 
 const STATE_FILE = path.join(HOME_DIR, '.tunnel-state');
+// Where `hop view` and `hop port` publish. Deliberately under HOME_DIR and
+// NOT under HAY_WEB_DIR, which resolves to hay/apps/web/dist — vite's own
+// outDir. That directory is gitignored AND emptied on every `npm run build`,
+// so every published deliverable silently vanished the next time anyone
+// rebuilt the web bundle. A view is the thing the human was waiting on; it
+// outlives a build.
+const VIEWS_DIR = path.join(HOME_DIR, 'views');
+// One-time move of anything published before that was understood. Best
+// effort: a failure here just means the old copies stay unreachable, which
+// is where they were headed anyway.
+function migrateLegacyViews() {
+    try {
+        const legacy = path.join(HAY_WEB_DIR, 'assets', 'view');
+        if (!fs.existsSync(legacy)) return;
+        for (const sess of fs.readdirSync(legacy)) {
+            const src = path.join(legacy, sess);
+            if (sess === 'manifest.json' || !fs.statSync(src).isDirectory()) continue;
+            const dst = path.join(VIEWS_DIR, sess);
+            fs.mkdirSync(dst, { recursive: true });
+            for (const f of fs.readdirSync(src)) {
+                const to = path.join(dst, f);
+                if (!fs.existsSync(to)) fs.copyFileSync(path.join(src, f), to);
+            }
+        }
+        fs.rmSync(legacy, { recursive: true, force: true });
+    } catch (e) { /* the new root still works */ }
+}
+
+// A view's TITLE, kept beside the files rather than in their names. An agent
+// hands over "ROC curve, new model vs baseline", not "roc_curve.png", and a
+// filename cannot carry that without becoming a filename nobody can type.
+// One sidecar per session dir so deleting a session's folder takes its
+// captions with it; dotfile so the manifest scan skips it.
+function viewMetaPath(session) { return path.join(VIEWS_DIR, session, '.meta.json'); }
+function readViewMeta(session) {
+    try { return JSON.parse(fs.readFileSync(viewMetaPath(session), 'utf8')) || {}; }
+    catch (e) { return {}; }
+}
+function writeViewMeta(session, meta) {
+    try { fs.writeFileSync(viewMetaPath(session), JSON.stringify(meta, null, 1)); }
+    catch (e) { /* a missing caption is not worth failing a publish over */ }
+}
+
+// Markdown, rendered at SERVE time rather than converted at publish time: the
+// stored file stays the file the agent wrote (re-publishable, diffable), and
+// the URL still reads like it. Deliberately small and dependency-free — hop
+// ships as one script and a markdown dependency is not worth a node_modules
+// entry. Covers what an agent actually emits in a result: headings, fenced
+// code, lists, tables, quotes, links, emphasis.
+function renderMarkdown(src, title) {
+    const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const blocks = [];
+    // Fenced code first, so nothing below rewrites its insides.
+    let text = src.replace(/```([\w-]*)\n([\s\S]*?)```/g, (m, lang, body) => {
+        blocks.push(`<pre class="code"><code>${esc(body.replace(/\n$/, ''))}</code></pre>`);
+        return `BLOCK${blocks.length - 1}`;
+    });
+    text = esc(text);
+    const inline = (s) => s
+        .replace(/`([^`]+)`/g, '<code>$1</code>')
+        .replace(/!\[([^\]]*)\]\(([^)\s]+)\)/g, '<img alt="$1" src="$2">')
+        .replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, '<a href="$2">$1</a>')
+        .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
+        .replace(/(^|[^*])\*([^*]+)\*/g, '$1<em>$2</em>');
+    const out = [];
+    const lines = text.split('\n');
+    let para = [], list = null, table = null;
+    const flushPara = () => { if (para.length) { out.push(`<p>${inline(para.join(' '))}</p>`); para = []; } };
+    const flushList = () => { if (list) { out.push(`<${list.tag}>${list.items.map((i) => `<li>${inline(i)}</li>`).join('')}</${list.tag}>`); list = null; } };
+    const flushTable = () => {
+        if (!table) return;
+        const cells = (row, tag) => row.map((c) => `<${tag}>${inline(c.trim())}</${tag}>`).join('');
+        out.push(`<table><thead><tr>${cells(table.head, 'th')}</tr></thead><tbody>`
+            + table.rows.map((r) => `<tr>${cells(r, 'td')}</tr>`).join('') + '</tbody></table>');
+        table = null;
+    };
+    const flushAll = () => { flushPara(); flushList(); flushTable(); };
+    const splitRow = (l) => l.replace(/^\||\|$/g, '').split('|');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^BLOCK\d+$/.test(line.trim())) { flushAll(); out.push(line.trim()); continue; }
+        if (!line.trim()) { flushAll(); continue; }
+        // A table needs its separator row to be a table at all.
+        if (!table && line.includes('|') && /^\s*\|?[\s:-]*-[\s:|-]*\|?\s*$/.test(lines[i + 1] || '')) {
+            flushPara(); flushList();
+            table = { head: splitRow(line), rows: [] };
+            i++;
+            continue;
+        }
+        if (table) {
+            if (line.includes('|')) { table.rows.push(splitRow(line)); continue; }
+            flushTable();
+        }
+        let m;
+        if ((m = line.match(/^(#{1,6})\s+(.*)$/))) {
+            flushAll();
+            out.push(`<h${m[1].length}>${inline(m[2])}</h${m[1].length}>`);
+        } else if (/^\s*([-*_])\s*\1\s*\1[\s\S]*$/.test(line) && line.trim().length >= 3
+                   && /^[-*_\s]+$/.test(line)) {
+            flushAll(); out.push('<hr>');
+        } else if ((m = line.match(/^\s*[-*+]\s+(.*)$/))) {
+            flushPara(); flushTable();
+            if (list?.tag !== 'ul') { flushList(); list = { tag: 'ul', items: [] }; }
+            list.items.push(m[1]);
+        } else if ((m = line.match(/^\s*\d+[.)]\s+(.*)$/))) {
+            flushPara(); flushTable();
+            if (list?.tag !== 'ol') { flushList(); list = { tag: 'ol', items: [] }; }
+            list.items.push(m[1]);
+        } else if ((m = line.match(/^&gt;\s?(.*)$/))) {
+            flushPara(); flushList(); flushTable();
+            out.push(`<blockquote>${inline(m[1])}</blockquote>`);
+        } else if (list && !para.length) {
+            // Lazy continuation: a wrapped bullet is still that bullet.
+            // Agents hard-wrap long list items constantly, and treating each
+            // wrap as a new block rendered a clean summary as a pile of
+            // one-item lists with orphaned paragraphs between them.
+            list.items[list.items.length - 1] += ' ' + line.trim();
+        } else {
+            flushList(); flushTable();
+            para.push(line.trim());
+        }
+    }
+    flushAll();
+    const body = out.join('\n').replace(/BLOCK(\d+)/g, (m, i) => blocks[Number(i)]);
+    return `<!doctype html><html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(title)}</title><style>
+:root { color-scheme: dark; }
+body { margin:0 auto; padding:24px 18px 64px; max-width:46rem; background:#0b0b12; color:#e8e6f0;
+  font:16px/1.65 -apple-system,"SF Pro Text",Helvetica,sans-serif; overflow-wrap:break-word; }
+h1,h2,h3,h4 { line-height:1.25; margin:1.6em 0 .5em; }
+h1 { font-size:1.7rem; } h2 { font-size:1.35rem; } h3 { font-size:1.12rem; }
+a { color:#a78bfa; }
+code { font-family:ui-monospace,"SF Mono",monospace; font-size:.87em; background:#201e2e;
+  padding:.12em .38em; border-radius:6px; }
+pre.code { background:#16151f; border:1px solid #2a2740; border-radius:12px; padding:12px 14px;
+  overflow-x:auto; } pre.code code { background:none; padding:0; font-size:.85rem; }
+blockquote { margin:1em 0; padding:.2em 0 .2em 1em; border-left:3px solid #3a3556; color:#b9b3d0; }
+table { border-collapse:collapse; width:100%; margin:1.2em 0; font-size:.93rem; display:block; overflow-x:auto; }
+th,td { border:1px solid #2a2740; padding:7px 10px; text-align:left; }
+th { background:#16151f; }
+hr { border:0; border-top:1px solid #2a2740; margin:2em 0; }
+img { max-width:100%; border-radius:10px; }
+</style></head><body>\n${body}\n</body></html>`;
+}
+
+// Names `--session` will accept, for the error that asks for one. Reading the
+// daemon's own list rather than the views folder: the answer to "where can
+// this go" is every live session, not just the ones that already published.
+function listPublishTargets(state) {
+    try {
+        const out = execFileSync(process.execPath, ['-e', `
+            const http = require('http');
+            http.get({ host: '127.0.0.1', port: ${Number(state.port)}, path: '/api/sessions',
+                       headers: { Cookie: 'tunnel_session=' + process.argv[1] } }, (r) => {
+                let b = ''; r.on('data', (c) => b += c);
+                r.on('end', () => {
+                    try {
+                        const d = JSON.parse(b);
+                        console.log((d.sessions || []).map((s) => s.internalName).join('\\n'));
+                    } catch (e) { }
+                });
+            }).on('error', () => {});
+        `, String(state.sessionSecret)], { encoding: 'utf8', timeout: 4000 });
+        return out.split('\n').map((s) => s.trim()).filter(Boolean).slice(0, 12);
+    } catch (e) {
+        return [];
+    }
+}
+
+// Runtime data written into the served assets dir — the briefing's
+// digest.json is the live example — is deleted by every web bundle rebuild,
+// because HAY_WEB_DIR resolves to vite's outDir when a dev build exists.
+// hop-ios's digest tool already mitigates half of this by writing to BOTH
+// candidate roots; the daemon only ever READ the first, so after a rebuild
+// the surviving copy sat unreachable and the wall's briefing 404'd. This
+// completes the other half: fall back to the packaged bundle for anything
+// the dev build doesn't have.
+function packagedAssetFallback(relPath) {
+    try {
+        const packagedRoot = path.resolve(path.join(__dirname, 'hay-web'));
+        if (path.resolve(HAY_WEB_DIR) === packagedRoot) return null;   // same dir already
+        const candidate = path.resolve(path.join(packagedRoot, relPath));
+        if (!candidate.startsWith(packagedRoot + path.sep)) return null;
+        return fs.existsSync(candidate) && fs.statSync(candidate).isFile() ? candidate : null;
+    } catch (e) {
+        return null;
+    }
+}
+
+// Per-session view facts for the sessions list: how many, how recent, and
+// what the newest one is called. Read from the manifest (already a cheap
+// single file) rather than re-scanning, and re-read only when it changes —
+// the sessions list is polled by every client, several times a minute.
+let viewSummaryCache = { mtimeMs: -1, bySession: {} };
+function viewSummaryBySession() {
+    try {
+        const mf = path.join(VIEWS_DIR, 'manifest.json');
+        const st = fs.statSync(mf);
+        if (st.mtimeMs !== viewSummaryCache.mtimeMs) {
+            const items = JSON.parse(fs.readFileSync(mf, 'utf8')).items || [];
+            const by = {};
+            for (const it of items) {
+                const cur = by[it.session];
+                // The manifest is newest-first, so the first one wins.
+                if (!cur) {
+                    by[it.session] = {
+                        count: 1, latestAt: it.mtime, latestName: it.name,
+                        latestTitle: it.title || '', latestPath: it.path
+                    };
+                } else cur.count += 1;
+            }
+            viewSummaryCache = { mtimeMs: st.mtimeMs, bySession: by };
+        }
+    } catch (e) {
+        viewSummaryCache = { mtimeMs: -1, bySession: {} };
+    }
+    return viewSummaryCache.bySession;
+}
+
+// The virtual folder both `hop view` and `hop port --attached` publish into:
+// clients browse every view through one manifest, REBUILT from a disk scan
+// rather than read-modify-written, so two agents publishing at once cannot
+// lose each other's entries — last writer wins with the same complete list
+// either way.
+//
+// MODULE scope, not the CLI's: the daemon serves the index too, and rebuilds
+// it on demand when it is missing. When this lived only in the CLI branch, a
+// manifest that disappeared (a wiped build dir, this release's storage move)
+// stayed gone until someone happened to publish again — the browser read
+// "Nothing published yet" over a folder full of files.
+function rebuildViewManifest() {
+    try {
+        migrateLegacyViews();
+        const entries = [];
+        for (const sess of fs.readdirSync(VIEWS_DIR)) {
+            const dir = path.join(VIEWS_DIR, sess);
+            if (sess === 'manifest.json' || sess.startsWith('.')
+                || !fs.statSync(dir).isDirectory()) continue;
+            const meta = readViewMeta(sess);
+            for (const f of fs.readdirSync(dir)) {
+                if (f.startsWith('.')) continue;         // the .meta.json sidecar
+                const st = fs.statSync(path.join(dir, f));
+                if (!st.isFile()) continue;
+                const m = meta[f] || {};
+                entries.push({
+                    session: sess,
+                    name: f,
+                    // What the agent SAID it was handing over. Clients lead
+                    // with this and fall back to the filename.
+                    title: m.title || '',
+                    // 'server' means a LIVE proxied localhost server rather
+                    // than a stored file: it can stop working when the server
+                    // does, and `target` is the proxy itself, so a client can
+                    // skip the redirect page the scan actually found.
+                    kind: m.kind === 'server' ? 'server' : 'file',
+                    target: m.kind === 'server' ? (m.target || '') : undefined,
+                    port: m.kind === 'server' ? m.port : undefined,
+                    // The extensionless serving path — see the /view route for
+                    // why the extension must stay off the URL's end.
+                    path: `/view/${encodeURIComponent(sess)}/${encodeURIComponent(f)}/inline`,
+                    bytes: st.size,
+                    mtime: Math.floor(st.mtimeMs / 1000)
+                });
+            }
+        }
+        entries.sort((a, b) => b.mtime - a.mtime);
+        const body = JSON.stringify({ items: entries }, null, 1);
+        fs.mkdirSync(VIEWS_DIR, { recursive: true });
+        fs.writeFileSync(path.join(VIEWS_DIR, 'manifest.json'), body);
+        return body;
+    } catch (e) {
+        return null;   // the links already printed still work without an index
+    }
+}
 const SESSION_SECRET_FILE = path.join(HOME_DIR, '.session_secret');
 // Folders live here, not in the workspace store: saveSessionStore() no-ops
 // without an active workspace (the common case), so folders and their order
@@ -237,6 +512,7 @@ const DEFAULT_PASSWORD_FILE = path.join(HOME_DIR, '.password_hash');
 const SESSION_COOKIE_NAME = 'tunnel_session';
 const LOG_DIR = path.join(HOME_DIR, 'logs');
 const SESSION_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+const UPLOAD_MAX_BYTES = parsePositiveIntEnv('HOP_UPLOAD_MAX_BYTES', 100 * 1024 * 1024);
 const DEFAULT_WORKSPACE_NAME = 'default';
 const HISTORY_DIR_NAME = 'history';
 const WORKSPACE_LOGS_DIR_NAME = 'logs';
@@ -5350,6 +5626,36 @@ function resolveActor(req) {
     return resolveActorFromHeaders(req?.headers || {}, ACTOR_HEADER);
 }
 
+// A dropped file's name is attacker-shaped input: it arrives as a query
+// param and becomes a filesystem path. Keep the basename only (so "../../.."
+// and absolute paths collapse to nothing), drop separators and control
+// characters, and bound the length while preserving the extension — the
+// extension is what makes an image open as an image downstream.
+function safeUploadFilename(raw) {
+    let name = typeof raw === 'string' ? raw : '';
+    name = name.replace(/[\x00-\x1f\x7f]/g, '');
+    name = path.basename(name.replace(/\\/g, '/'));
+    name = name.replace(/[/:]/g, '-').trim();
+    if (name === '' || name === '.' || name === '..') return 'dropped-file';
+    if (name.length > 120) {
+        const ext = path.extname(name).slice(0, 16);
+        name = name.slice(0, 120 - ext.length) + ext;
+    }
+    return name;
+}
+
+// Never overwrite: a second drop of "screenshot.png" is a second file, not a
+// replacement of the one the user may still be pointing an agent at.
+function uniqueUploadPath(dir, filename) {
+    const ext = path.extname(filename);
+    const stem = filename.slice(0, filename.length - ext.length);
+    let candidate = path.join(dir, filename);
+    for (let i = 1; fs.existsSync(candidate) && i < 1000; i++) {
+        candidate = path.join(dir, `${stem}-${i}${ext}`);
+    }
+    return candidate;
+}
+
 function resolveSessionInternalName(name, internalName) {
     if (internalName && (getEffectiveSessionConfig(internalName) || hopSessionExists(internalName))) return internalName;
     if (!name) return null;
@@ -7471,14 +7777,78 @@ const STATIC_CONTENT_TYPES = {
     '.svg': 'image/svg+xml',
     '.ico': 'image/x-icon',
     '.pdf': 'application/pdf',
+    // Everything below renders natively in a browser AND in the iOS app's
+    // WKWebView, so the only thing standing between a result and the human
+    // was this table. An unlisted extension falls back to octet-stream, which
+    // DOWNLOADS instead of rendering — the exact defeat the feature exists to
+    // avoid, and how .pdf itself behaved until the first live test.
+    '.heic': 'image/heic',
+    '.heif': 'image/heif',
+    '.avif': 'image/avif',
+    '.bmp': 'image/bmp',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+    '.apng': 'image/apng',
     '.mp4': 'video/mp4',
+    '.m4v': 'video/mp4',
     '.mov': 'video/quicktime',
     '.webm': 'video/webm',
+    '.ogv': 'video/ogg',
+    '.mp3': 'audio/mpeg',
+    '.m4a': 'audio/mp4',
+    '.aac': 'audio/aac',
+    '.wav': 'audio/wav',
+    '.flac': 'audio/flac',
+    '.oga': 'audio/ogg',
+    '.ogg': 'audio/ogg',
+    '.opus': 'audio/ogg',
     '.txt': 'text/plain; charset=utf-8',
+    '.log': 'text/plain; charset=utf-8',
+    '.xml': 'text/xml; charset=utf-8',
+    '.yaml': 'text/plain; charset=utf-8',
+    '.yml': 'text/plain; charset=utf-8',
+    '.ics': 'text/calendar; charset=utf-8',
     '.md': 'text/plain; charset=utf-8'
 };
 
+// Extensions we RENDER rather than hand over raw, because the raw form is
+// unreadable on a phone and the rendered form is the actual result.
+const VIEW_RENDERED = new Set(['.md', '.markdown', '.csv', '.tsv', '.json']);
+
+/// Delimited data as a table. A CSV is a RESULT — the numbers an agent
+/// computed — and delivering it as one long line of commas on a phone is the
+/// "just text" failure with extra steps. Quote-aware because a cell
+/// containing a comma is the normal case in real data, not an edge case.
+function renderDelimited(src, title, delim) {
+    const rows = [];
+    let row = [], cell = '', quoted = false;
+    for (let i = 0; i < src.length; i++) {
+        const c = src[i];
+        if (quoted) {
+            if (c === '"' && src[i + 1] === '"') { cell += '"'; i++; }
+            else if (c === '"') quoted = false;
+            else cell += c;
+        } else if (c === '"') quoted = true;
+        else if (c === delim) { row.push(cell); cell = ''; }
+        else if (c === '\n') { row.push(cell); rows.push(row); row = []; cell = ''; }
+        else if (c !== '\r') cell += c;
+    }
+    if (cell.length || row.length) { row.push(cell); rows.push(row); }
+    const body = rows.filter((r) => r.length && !(r.length === 1 && r[0] === ''));
+    if (!body.length) return renderMarkdown('_(empty)_', title);
+    // Markdown's own table syntax, so one renderer styles both — and a cell
+    // holding a pipe would otherwise break the table it lives in.
+    const esc = (s) => String(s).replace(/\|/g, '\\|').trim();
+    const head = body[0].map(esc);
+    const md = [`# ${title}`, '', `| ${head.join(' | ')} |`,
+                `|${head.map(() => '---').join('|')}|`,
+                ...body.slice(1).map((r) => `| ${r.map(esc).join(' | ')} |`),
+                '', `_${body.length - 1} rows_`].join('\n');
+    return renderMarkdown(md, title);
+}
+
 function startAuthProxy(authEmitter) {
+    migrateLegacyViews();
     log(`[2/4] Starting Session Manager on port ${PROXY_PORT}...`, BOLD);
 
     const server = http.createServer(async (req, res) => {
@@ -8064,7 +8434,7 @@ function startAuthProxy(authEmitter) {
         const viewMatch = req.method === 'GET'
             && parsedUrl.pathname.match(/^\/view\/([^/]+)\/([^/]+?)(\/inline)?$/);
         if (viewMatch) {
-            const viewRoot = path.resolve(path.join(HAY_WEB_DIR, 'assets', 'view'));
+            const viewRoot = path.resolve(VIEWS_DIR);
             const target = path.resolve(path.join(
                 viewRoot, decodeURIComponent(viewMatch[1]), decodeURIComponent(viewMatch[2])));
             if (!target.startsWith(viewRoot + path.sep)
@@ -8073,20 +8443,58 @@ function startAuthProxy(authEmitter) {
                 res.end('Not found');
                 return;
             }
+            const viewExt = path.extname(target).toLowerCase();
+            // Markdown is rendered, not dumped: an agent's write-up is a
+            // RESULT, and handing over a wall of raw asterisks is the "just
+            // text" outcome this feature exists to avoid. The stored file
+            // stays the markdown the agent wrote.
+            if (VIEW_RENDERED.has(viewExt)) {
+                const sess = decodeURIComponent(viewMatch[1]);
+                const file = decodeURIComponent(viewMatch[2]);
+                const caption = readViewMeta(sess)[file]?.title || file;
+                const raw = fs.readFileSync(target, 'utf8');
+                let html;
+                if (viewExt === '.csv') html = renderDelimited(raw, caption, ',');
+                else if (viewExt === '.tsv') html = renderDelimited(raw, caption, '\t');
+                else if (viewExt === '.json') {
+                    // Pretty-printed in a code block: a minified blob is
+                    // machine output, and the human opened this to read it.
+                    let pretty = raw;
+                    try { pretty = JSON.stringify(JSON.parse(raw), null, 2); } catch (e) { }
+                    html = renderMarkdown(`# ${caption}\n\n\`\`\`json\n${pretty}\n\`\`\``, caption);
+                } else html = renderMarkdown(raw, caption);
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(html);
+                return;
+            }
             res.writeHead(200, {
-                'Content-Type': STATIC_CONTENT_TYPES[path.extname(target).toLowerCase()] || 'application/octet-stream'
+                'Content-Type': STATIC_CONTENT_TYPES[viewExt] || 'application/octet-stream'
             });
             res.end(fs.readFileSync(target));
             return;
         }
+        // The index. /assets/view/manifest.json is the URL every SHIPPED iOS
+        // build fetches, so it keeps working forever regardless of where the
+        // files actually live; /api/views is the same bytes under a name that
+        // describes what it is, for clients written after the move.
+        if (req.method === 'GET' && (parsedUrl.pathname === '/assets/view/manifest.json'
+                                     || parsedUrl.pathname === '/api/views')) {
+            let body = null;
+            try { body = fs.readFileSync(path.join(VIEWS_DIR, 'manifest.json'), 'utf8'); } catch (e) { }
+            // Rebuild rather than answer "nothing published" over a folder
+            // that has files in it.
+            if (body === null) body = rebuildViewManifest();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(body || '{"items":[]}');
+            return;
+        }
         if (req.method === 'GET' && parsedUrl.pathname.startsWith('/assets/view/')) {
             const segs = parsedUrl.pathname.slice('/assets/view/'.length).split('/');
-            if (segs.length === 2 && segs[1] && segs[1] !== 'manifest.json') {
+            if (segs.length === 2 && segs[1]) {
                 res.writeHead(302, { Location: `/view/${segs[0]}/${segs[1]}/inline` });
                 res.end();
                 return;
             }
-            // manifest.json falls through to plain static serving
         }
 
         if (sessionInfoAuth && sessionInfoAuth.source === 'query' && shouldRedirectToSessionPath(req)) {
@@ -8396,7 +8804,16 @@ function startAuthProxy(authEmitter) {
             const visibleEntries = snapshot.entries.filter((s) =>
                 !(s.type === 'port' && getEffectiveSessionConfig(s.internalName)?.attachedTo)
             );
+            // What each session has published, folded into the list every
+            // client already polls. Deliberately NOT a server-side unread
+            // counter: "new" is per-DEVICE (the phone can be behind while the
+            // wall is caught up), so the server states the facts — how many,
+            // how recent, what the newest one is called — and each client
+            // compares latestAt against its own last-seen mark. No new state,
+            // no new poll, and the badge works the same everywhere.
+            const viewsBySession = viewSummaryBySession();
             const sessions = visibleEntries.map(s => ({
+                views: viewsBySession[s.internalName] || undefined,
                 name: s.displayName,
                 displayName: s.displayName,
                 internalName: s.internalName,
@@ -8677,6 +9094,67 @@ function startAuthProxy(authEmitter) {
             return;
         }
 
+        // API: Upload a dropped file. A browser never reveals a dropped
+        // file's real path, so the old drop handler could only apologise and
+        // teach the OS copy-path gesture. Take the BYTES instead: the file
+        // lands on the host in a per-session staging dir and the terminal is
+        // handed a path the shell (or the agent reading it) can actually
+        // open. Staging — never the session's cwd — so a drop can't clobber
+        // a working file or dirty a repo.
+        if (parsedUrl.pathname === '/api/sessions/upload' && req.method === 'POST') {
+            const internalName = resolveSessionInternalName(parsedUrl.query.name, parsedUrl.query.internalName);
+            // resolveSessionInternalName INVENTS a name for anything it does
+            // not know (the invent-on-connect path), so an unknown session
+            // would otherwise become a staging directory on demand: an
+            // unbounded write surface keyed by a caller-supplied string.
+            // Uploads go only to sessions that actually exist.
+            const uploadSessionExists = internalName
+                && (getEffectiveSessionConfig(internalName) || hopSessionExists(internalName));
+            if (!internalName || !SESSION_NAME_RE.test(internalName) || !uploadSessionExists) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Session not found' }));
+                return;
+            }
+            const declaredLength = Number(req.headers['content-length']);
+            if (Number.isFinite(declaredLength) && declaredLength > UPLOAD_MAX_BYTES) {
+                res.writeHead(413, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: `File too large (max ${Math.floor(UPLOAD_MAX_BYTES / 1048576)}MB)` }));
+                return;
+            }
+            const chunks = [];
+            let received = 0;
+            let aborted = false;
+            req.on('data', (chunk) => {
+                if (aborted) return;
+                received += chunk.length;
+                if (received > UPLOAD_MAX_BYTES) {
+                    aborted = true;
+                    res.writeHead(413, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: `File too large (max ${Math.floor(UPLOAD_MAX_BYTES / 1048576)}MB)` }));
+                    req.destroy();
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            req.on('end', () => {
+                if (aborted) return;
+                try {
+                    const dir = path.join(HOME_DIR, 'uploads', internalName);
+                    fs.mkdirSync(dir, { recursive: true });
+                    const filePath = uniqueUploadPath(dir, safeUploadFilename(parsedUrl.query.filename));
+                    fs.writeFileSync(filePath, Buffer.concat(chunks), { mode: 0o600 });
+                    log(`[upload] ${getSessionDisplayName(internalName) || internalName}: ${path.basename(filePath)} (${received} bytes)`, DIM);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, path: filePath, name: path.basename(filePath), bytes: received }));
+                } catch (e) {
+                    log(`[upload] failed for ${internalName}: ${e.message}`, YELLOW);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Upload failed' }));
+                }
+            });
+            return;
+        }
+
         // API: Session tagline — a short human-readable line describing what
         // the session is working on. Written by `hop ai tagline` (the only
         // AI-dependent surface; core hop never calls a model). Stored on the
@@ -9914,7 +10392,7 @@ function startAuthProxy(authEmitter) {
             let hubPath = isRootAsset
                 ? path.join(HAY_WEB_DIR, parsedUrl.pathname)
                 : path.join(HAY_WEB_DIR, 'index.html');
-            const resolvedHub = path.resolve(hubPath);
+            let resolvedHub = path.resolve(hubPath);
             const hubRoot = path.resolve(HAY_WEB_DIR);
             if (resolvedHub !== hubRoot && !resolvedHub.startsWith(hubRoot + path.sep)) {
                 res.writeHead(403);
@@ -9922,9 +10400,14 @@ function startAuthProxy(authEmitter) {
                 return;
             }
             if (!fs.existsSync(resolvedHub)) {
-                res.writeHead(404);
-                res.end('Not Found');
-                return;
+                const fallback = isRootAsset && packagedAssetFallback(parsedUrl.pathname);
+                if (!fallback) {
+                    res.writeHead(404);
+                    res.end('Not Found');
+                    return;
+                }
+                hubPath = fallback;
+                resolvedHub = fallback;
             }
             const hubExt = path.extname(resolvedHub).toLowerCase();
             const hubTypes = STATIC_CONTENT_TYPES;
@@ -10074,9 +10557,15 @@ function startAuthProxy(authEmitter) {
 
         // Check if file exists
         if (!fs.existsSync(filePath)) {
-            res.writeHead(404);
-            res.end('Not Found');
-            return;
+            // Same packaged fallback as hub scope — a rebuild must not take
+            // the briefing out from under a session-scoped page either.
+            const fallback = reqPath.startsWith('/assets/') && packagedAssetFallback(reqPath);
+            if (!fallback) {
+                res.writeHead(404);
+                res.end('Not Found');
+                return;
+            }
+            filePath = fallback;
         }
 
         // Determine content type
@@ -12172,7 +12661,7 @@ async function attachToAllSessions(existingTunnel) {
 const KNOWN_COMMANDS = [
     'client', 'start', 'attach', 'local', 'stop', 'status', 'doctor', 'logs',
     'help', 'config', 'url', 'qr', 'health', 'domain', 'domain-clear',
-    'password', 'user', 'workspace', 'session', 'wipe', 'restore', 'update', 'resume-waiting', 'claude-hook', 'claude-skill', 'agent-skill', 'math', 'view', 'notify', 'new'
+    'password', 'user', 'workspace', 'session', 'wipe', 'restore', 'update', 'resume-waiting', 'claude-hook', 'claude-skill', 'agent-skill', 'math', 'view', 'port', 'notify', 'new'
 ];
 
 // Suggest the closest known command for typos (small edit distances only).
@@ -12285,6 +12774,17 @@ const HELP_SECTIONS = [
     { title: 'Math', lines: [
         `hop math '<latex>'        Render a LaTeX formula (inline image where supported, else Unicode)`,
     ] },
+    // Was missing entirely: an agent in a session with no skill installed had
+    // no way to learn these existed, and `hop port --help` printed "Unknown
+    // command" because 'port' wasn't in KNOWN_COMMANDS.
+    { title: 'Views (show the human something a terminal cannot draw)', lines: [
+        `hop view <file...>        Publish HTML/PDF/image/video/markdown behind hop's auth and print the link`,
+        `hop view --title "..."    Say what the result IS — clients lead with this, not the filename`,
+        `hop view --name x.md -    Publish what's on stdin (no temp file needed)`,
+        `hop view --list [--all]   What this session has published (--all: the whole fleet)`,
+        `hop view --rm <name>      Unpublish one`,
+        `hop port <port> [name]    Expose a local web server (live proxy, WebSocket-safe); --standalone to detach`,
+    ] },
     { title: 'Maintenance', lines: [
         `hop health [--restart]    Check tunnel health (--restart forces a tunnel restart)`,
         `hop wipe [--all] [--yes]  Remove workspace-defined sessions (--all kills live; --yes skips confirmation)`,
@@ -13300,39 +13800,6 @@ async function main() {
         process.exit(0);
     }
 
-    // The virtual folder both `hop view` and `hop port --attached` publish
-    // into: clients browse every artifact through one manifest, REBUILT from
-    // a disk scan on every publish rather than read-modify-written, so two
-    // agents publishing at once cannot lose each other's entries — last
-    // writer wins with the same complete list either way.
-    function rebuildArtifactManifest() {
-        try {
-            const viewRoot = path.join(HAY_WEB_DIR, 'assets', 'view');
-            const entries = [];
-            for (const sess of fs.readdirSync(viewRoot)) {
-                const dir = path.join(viewRoot, sess);
-                if (!fs.statSync(dir).isDirectory()) continue;
-                for (const f of fs.readdirSync(dir)) {
-                    if (f === 'manifest.json') continue;
-                    const st = fs.statSync(path.join(dir, f));
-                    if (!st.isFile()) continue;
-                    entries.push({
-                        session: sess,
-                        name: f,
-                        // The extensionless serving path — see the /view route
-                        // for why the extension must stay off the URL's end.
-                        path: `/view/${encodeURIComponent(sess)}/${encodeURIComponent(f)}/inline`,
-                        bytes: st.size,
-                        mtime: Math.floor(st.mtimeMs / 1000)
-                    });
-                }
-            }
-            entries.sort((a, b) => b.mtime - a.mtime);
-            fs.writeFileSync(path.join(viewRoot, 'manifest.json'),
-                             JSON.stringify({ items: entries }, null, 1));
-        } catch { /* the links already printed still work without a manifest */ }
-    }
-
     // hop view <file...> — publish a renderable artifact (HTML, PDF, image)
     // behind hop's auth and print the link. The browser is the viewer: every
     // hop client either is one (web) or carries one (the iOS app opens these
@@ -13341,36 +13808,121 @@ async function main() {
     // the session cookie like everything else. Written for agents (the
     // hop-session skill teaches it): show the human the plot, don't describe it.
     if (process.argv[2] === 'view') {
-        const files = process.argv.slice(3).filter((a) => !a.startsWith('-'));
+        const argv = process.argv.slice(3);
+        const flagValue = (name) => {
+            const i = argv.indexOf(name);
+            return i >= 0 ? argv[i + 1] : null;
+        };
+        const title = flagValue('--title') || '';
+        const stdinName = flagValue('--name');
+        const wantList = argv.includes('--list');
+        const removals = argv.reduce((acc, a, i) => (a === '--rm' && argv[i + 1] ? acc.concat(argv[i + 1]) : acc), []);
+        const wantSession = flagValue('--session');
+        const consumed = new Set(['--title', title, '--name', stdinName, '--session', wantSession,
+                                  '--list', '--rm', ...removals]);
+        const files = argv.filter((a) => !consumed.has(a) && (a === '-' || !a.startsWith('-')));
+        // WHICH session a result belongs to is the whole filing system: the
+        // chip that lights, the panel it appears in, the conversation it
+        // answers. It used to be `HOP_SESSION || 'shared'`, and that fallback
+        // was a silent misdelivery — 'shared' is not a session, so nothing
+        // resolves it to a name, no session's summary counts it, and no chip
+        // ever lights. The result was published to a folder nobody is looking
+        // at. (Not hypothetical: we deliberately scrub HOP_SESSION from
+        // subprocesses to keep claude's session identity straight, and a cron
+        // or MCP-driven agent never had it.)
+        //
+        // So: explicit --session wins, the environment is the convenience
+        // default, and having neither is an ERROR that says how to fix it —
+        // never a quiet write into the void.
+        const session = wantSession || process.env.HOP_SESSION || '';
+        const destDir = path.join(VIEWS_DIR, session);
+
+        if (wantList) {
+            const items = (JSON.parse(rebuildViewManifest() || '{"items":[]}').items || [])
+                .filter((i) => argv.includes('--all') || i.session === session);
+            if (!items.length) { log(`No views published${argv.includes('--all') ? '' : ` by ${session}`} yet.`, DIM); process.exit(0); }
+            for (const i of items) {
+                console.log(`${i.session}/${i.name}${i.title ? `  — ${i.title}` : ''}  (${Math.max(1, Math.round(i.bytes / 1024))} KB)`);
+            }
+            process.exit(0);
+        }
+        if (removals.length) {
+            let gone = 0;
+            const meta = readViewMeta(session);
+            for (const name of removals) {
+                const target = path.resolve(path.join(destDir, path.basename(name)));
+                if (!target.startsWith(path.resolve(destDir) + path.sep) || !fs.existsSync(target)) {
+                    log(`hop view: not published here: ${name}`, RED);
+                    continue;
+                }
+                fs.rmSync(target); delete meta[path.basename(name)]; gone += 1;
+            }
+            writeViewMeta(session, meta);
+            rebuildViewManifest();
+            log(`Removed ${gone} view${gone === 1 ? '' : 's'}.`, gone ? GREEN : RESET);
+            process.exit(gone ? 0 : 1);
+        }
         if (files.length === 0) {
-            log('Usage: hop view <file...>   (HTML, PDF, images — anything a browser renders)', YELLOW);
+            log('Usage: hop view [--title "what this is"] <file...>', YELLOW);
+            log('       hop view --name report.md --title "..." -     (read the file from stdin)', DIM);
+            log('       hop view --list [--all]                        hop view --rm <name>', DIM);
+            log('HTML, PDF, images, video, markdown — anything a browser renders.', DIM);
             process.exit(1);
         }
         const state = isServerRunning();
         if (!state) { printNotRunningError(); process.exit(1); }
-        const session = process.env.HOP_SESSION || 'shared';
-        const destDir = path.join(HAY_WEB_DIR, 'assets', 'view', session);
+        if (!session) {
+            log('hop view: no session to publish into.', RED);
+            log('  Inside a hop session this is automatic (HOP_SESSION).', DIM);
+            log('  From anywhere else, name the session the result belongs to:', DIM);
+            log(`     hop view --session <name> --title "..." <file>`, CYAN);
+            log(`  ${DIM}Sessions:${RESET} ${listPublishTargets(state).join(', ') || '(none)'}`, RESET);
+            process.exit(2);
+        }
         fs.mkdirSync(destDir, { recursive: true });
+        const meta = readViewMeta(session);
         let failed = 0;
+        const published = [];
         for (const file of files) {
-            const src = path.resolve(file);
-            if (!fs.existsSync(src) || !fs.statSync(src).isFile()) {
-                log(`hop view: no such file: ${file}`, RED);
-                failed += 1;
-                continue;
+            let name;
+            if (file === '-') {
+                // Stdin: an agent that GENERATED the result shouldn't have to
+                // invent a temp file to hand it over. Markdown by default —
+                // it renders, and it's what a model writes without being asked.
+                name = path.basename(stdinName || 'result.md');
+                try {
+                    fs.writeFileSync(path.join(destDir, name), fs.readFileSync(0));
+                } catch (e) {
+                    log(`hop view: could not read stdin: ${e.message}`, RED);
+                    failed += 1;
+                    continue;
+                }
+            } else {
+                const src = path.resolve(file);
+                if (!fs.existsSync(src) || !fs.statSync(src).isFile()) {
+                    log(`hop view: no such file: ${file}`, RED);
+                    failed += 1;
+                    continue;
+                }
+                // Basename only — the URL should read like the file, and the
+                // session subdir already namespaces collisions between agents.
+                name = path.basename(src);
+                fs.copyFileSync(src, path.join(destDir, name));
             }
-            // Basename only — the URL should read like the file, and the
-            // session subdir already namespaces collisions between agents.
-            const dest = path.join(destDir, path.basename(src));
-            fs.copyFileSync(src, dest);
-            console.log(`View: ${state.url}/view/${encodeURIComponent(session)}/${encodeURIComponent(path.basename(src))}/inline`);
+            // One title covers the batch: a caption describes the HANDOFF
+            // ("the before/after plots"), and repeating it per file reads
+            // worse than sharing it.
+            if (title) meta[name] = { ...(meta[name] || {}), title };
+            published.push(name);
+            console.log(`View: ${state.url}/view/${encodeURIComponent(session)}/${encodeURIComponent(name)}/inline`);
         }
+        if (published.length) writeViewMeta(session, meta);
         if (failed === 0 && files.length > 0) {
-            // One bell: the artifact is usually the deliverable the human is
+            // One bell: the view is usually the deliverable the human is
             // waiting on, and the link scrolls away if nothing pings them.
             process.stdout.write('\x07');
         }
-        rebuildArtifactManifest();
+        rebuildViewManifest();
         process.exit(failed > 0 ? 1 : 0);
     }
 
@@ -13422,7 +13974,7 @@ async function main() {
             // in-app open on web) navigates through it to the live proxy in
             // one hop — same auth, same session cookie, no new plumbing on
             // either client.
-            const destDir = path.join(HAY_WEB_DIR, 'assets', 'view', caller);
+            const destDir = path.join(VIEWS_DIR, caller);
             fs.mkdirSync(destDir, { recursive: true });
             const artifactName = `${label}.html`;
             fs.writeFileSync(path.join(destDir, artifactName), [
@@ -13431,7 +13983,21 @@ async function main() {
                 `<meta http-equiv="refresh" content="0;url=${proxyUrl}">`,
                 '</head><body>Redirecting to the live server…</body></html>'
             ].join(''));
-            rebuildArtifactManifest();
+            // A running server is not a file, and a row reading "probe.html"
+            // told the human nothing about what it actually was. The metadata
+            // says what it IS and where it really lives, so clients can send
+            // the tap straight to the proxy instead of through the redirect
+            // page, and can label it as something live that can go away.
+            const meta = readViewMeta(caller);
+            meta[artifactName] = {
+                ...(meta[artifactName] || {}),
+                title: `${label} — live server on port ${port}`,
+                kind: 'server',
+                target: `/s/${encodeURIComponent(linkName)}/`,
+                port
+            };
+            writeViewMeta(caller, meta);
+            rebuildViewManifest();
             console.log(`View: ${proxyUrl}`);
             console.log(`Attached to ${caller} — also in its Views.`);
         } else {