hop2 0.11.13 → 0.11.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.13",
+  "version": "0.11.15",
   "description": "🐰 Hop into your terminal from anywhere. Secure remote shell access with 2FA via Cloudflare Tunnel. Next-gen rewrite with native terminal sharing.",
   "main": "hop",
   "bin": {

package/skills/hop-session/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: hop-session
-description: Conventions for agents working inside a hop terminal session (the HOP_SESSION environment variable is set). Humans watch these terminals live, often from a phone. Covers rendering math with hop math, publishing viewable files (HTML/PDF/images) with hop view, exposing a running local web server with hop port, ringing the bell for attention, and phone-friendly output.
+description: Conventions for agents working inside a hop terminal session (the HOP_SESSION environment variable is set). Humans watch these terminals live, often from a phone. Covers rendering math with hop math, handing over results a terminal cannot render — plots, PDFs, images, rendered markdown write-ups — with hop view (always with --title), exposing a running local web server with hop port, ringing the bell for attention, and phone-friendly output.
 ---
 
 # Working in a hop terminal
@@ -24,21 +24,42 @@ formula in your response; do not repeat the raw LaTeX next to it. When you
 need the rendered text inside a file or message, capture it:
 `hop math '<latex>'` and copy the command's output verbatim.
 
-## Showing files a terminal cannot render (HTML, PDF, images)
+## Showing results a terminal cannot render (plots, PDFs, write-ups)
 
-When the deliverable is a plot, a figure, an HTML report, a PDF, or any
-image, do not describe it — publish it and hand over the link:
+When the deliverable is a plot, a figure, a report, a PDF, an image, or a
+write-up worth reading as a document, do not describe it — publish it and
+hand over the link:
 
 ```bash
-hop view results/roc_curve.png
-hop view report.html analysis.pdf
+hop view --title "ROC curve: new model vs baseline" results/roc_curve.png
+hop view --title "Q3 regression analysis" report.html analysis.pdf
 ```
 
-`hop view` copies the file behind hop's auth and prints a `View:` URL. The
-human taps it and their browser renders it — on the desktop wall or from the
-phone app, which opens these in-app. It rings the bell once for you, since a
-published file is usually the thing the human is waiting on. Re-running
-it after updating the file re-publishes under the same link.
+**Always pass `--title`.** It is what the human sees in the session's Views
+list and in the "new result" chip — a filename like `roc_curve.png` makes
+them open it to find out what it is; a title means they already know. One
+title describes the whole handoff, so publishing three plots under
+"before/after/diff for the cache change" reads correctly.
+
+Markdown is a first-class result, and you can pipe it straight from stdout
+with no temp file — it is **rendered** (headings, tables, fenced code,
+quotes), not dumped as raw text:
+
+```bash
+generate_summary | hop view --name findings.md --title "What the profiler found" -
+```
+
+Reach for this whenever the answer is long enough that reading it in a
+terminal is worse than reading it as a page: comparisons, tables of numbers,
+anything with structure. A table in the scrollback of a phone terminal is
+close to unreadable; the same table as a view is not.
+
+`hop view` copies the file behind hop's auth and prints a `View:` URL. It
+rings the bell once for you, since a published result is usually the thing
+the human is waiting on, and the session's Views surface shows it as new.
+Re-running after updating the file re-publishes under the same link.
+`hop view --list` shows what this session has published; `hop view --rm
+<name>` unpublishes.
 
 ## Showing a running web server (dev server, local app)
 

package/tests/terminal-api.integration.test.cjs

@@ -734,3 +734,87 @@ test('an idle agent terminal attach is reaped after the TTL', async () => {
   await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/delete',
     { name: 'idle-agent-probe', internalName: s.internalName });
 });
+
+// Dropping a file into the web terminal uploads its BYTES (a browser never
+// reveals the real path) and hands back a host path the session can open.
+// The filename is attacker-shaped input on its way to becoming a path.
+function requestUpload(port, secret, reqPath, buffer) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port,
+      path: reqPath,
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${secret}`,
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': buffer.length
+      }
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, data: data ? JSON.parse(data) : null }); }
+        catch (e) { resolve({ status: res.statusCode, data }); }
+      });
+    });
+    req.on('error', reject);
+    req.end(buffer);
+  });
+}
+
+test('a dropped file uploads to host staging and never escapes it', async () => {
+  const create = await requestJson(state.port, state.sessionSecret, 'POST', '/api/terminals', {
+    name: 'upload-probe',
+    cwd: tempDir
+  }, agentHeaders);
+  assert.equal(create.status, 200);
+  const session = create.data.sessionName;
+
+  // Every byte value, so a text-mode body handler would visibly corrupt it.
+  const bytes = Buffer.from(Array.from({ length: 256 }, (_, i) => i));
+  const up = await requestUpload(
+    state.port, state.sessionSecret,
+    `/api/sessions/upload?name=${encodeURIComponent(session)}&filename=shot.png`,
+    bytes
+  );
+  assert.equal(up.status, 200);
+  assert.ok(up.data.path, 'returns the host path');
+  const landed = await fs.readFile(up.data.path);
+  assert.ok(landed.equals(bytes), 'bytes survive the round trip unmodified');
+  assert.equal(path.basename(up.data.path), 'shot.png');
+  assert.ok(up.data.path.startsWith(path.join(hopHome, 'uploads')),
+    `staged under HOP_HOME/uploads, got ${up.data.path}`);
+
+  // A second drop of the same name is a second file, not an overwrite.
+  const again = await requestUpload(
+    state.port, state.sessionSecret,
+    `/api/sessions/upload?name=${encodeURIComponent(session)}&filename=shot.png`,
+    Buffer.from('second')
+  );
+  assert.equal(again.status, 200);
+  assert.notEqual(again.data.path, up.data.path, 'collision gets its own path');
+  assert.ok((await fs.readFile(up.data.path)).equals(bytes), 'first upload untouched');
+
+  // Traversal in the filename must collapse to a basename inside staging.
+  const evil = await requestUpload(
+    state.port, state.sessionSecret,
+    `/api/sessions/upload?name=${encodeURIComponent(session)}&filename=${encodeURIComponent('../../../../etc/hop-pwned')}`,
+    Buffer.from('nope')
+  );
+  assert.equal(evil.status, 200);
+  assert.ok(evil.data.path.startsWith(path.join(hopHome, 'uploads')),
+    `traversal stayed in staging, got ${evil.data.path}`);
+  assert.equal(path.basename(evil.data.path), 'hop-pwned');
+
+  // An unknown session is not a place to write files.
+  const nowhere = await requestUpload(
+    state.port, state.sessionSecret,
+    '/api/sessions/upload?name=no-such-session-here&filename=x.txt',
+    Buffer.from('x')
+  );
+  assert.equal(nowhere.status, 404);
+
+  await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/delete',
+    { name: 'upload-probe', internalName: session });
+});