dsh-zen-remote 1.0.0

package/scripts/cdp-probe.mjs

@@ -0,0 +1,64 @@
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+const CHROME = '/data/data/com.termux/files/usr/lib/chromium/chrome';
+const SESSION = 'session-cd1f3fcc-ec1a-4b51-b7c1-840d9359bc18';
+const PROFILE = '/data/data/com.termux/files/home/.cache/cdp-probe-' + Date.now();
+const port = await new Promise((resolve, reject) => {
+  const srv = net.createServer();
+  srv.listen(0, '127.0.0.1', () => { const p = srv.address().port; srv.close(() => resolve(p)); });
+  srv.on('error', reject);
+});
+const chrome = spawn(CHROME, ['--headless=new', '--no-sandbox', '--disable-dev-shm-usage', '--remote-debugging-port=' + port, '--user-data-dir=' + PROFILE, '--window-size=390,844', 'about:blank'], { stdio: 'ignore' });
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+async function getJson(path) { const res = await fetch('http://127.0.0.1:' + port + path); return res.json(); }
+async function waitForTarget() { for (let i = 0; i < 60; i++) { try { const l = await getJson('/json'); if (l.length) return l[0]; } catch {} await sleep(300); } throw new Error('no target'); }
+let msgId = 0; const pending = new Map(); let ws;
+function send(method, params = {}) { return new Promise((resolve, reject) => { const id = ++msgId; pending.set(id, { resolve, reject }); ws.send(JSON.stringify({ id, method, params })); }); }
+async function evaluate(expression) {
+  const r = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true });
+  if (r.exceptionDetails) return { __evalError: String(r.exceptionDetails.exception?.description || r.exceptionDetails.text).slice(0, 200) };
+  return r.result.value;
+}
+async function main() {
+  const target = await waitForTarget();
+  ws = new WebSocket(target.webSocketDebuggerUrl);
+  await new Promise((resolve, reject) => { ws.onopen = resolve; ws.onerror = reject; });
+  ws.onmessage = (ev) => { const msg = JSON.parse(ev.data); if (msg.id && pending.has(msg.id)) { const { resolve, reject } = pending.get(msg.id); pending.delete(msg.id); msg.error ? reject(new Error(JSON.stringify(msg.error))) : resolve(msg.result); } };
+  await send('Page.enable'); await send('Runtime.enable');
+  await send('Emulation.setDeviceMetricsOverride', { width: 390, height: 844, deviceScaleFactor: 2, mobile: true });
+  await send('Page.navigate', { url: 'http://127.0.0.1:3080/' });
+  await sleep(8000);
+  await evaluate(`localStorage.setItem('dsh.sessions.current', JSON.stringify({ sessionId: '${SESSION}' }));`);
+  await send('Page.reload');
+  let ready = false;
+  for (let i = 0; i < 25; i++) {
+    await sleep(2000);
+    ready = await evaluate(`!!document.querySelector('[data-gitgraph-chip-anchor] [data-gitgraph-chip]')`);
+    if (ready) break;
+  }
+  if (!ready) { console.log('chip not found'); process.exit(0); }
+  // 1. computed styles of the enlarged chip
+  const styles = await evaluate(`(() => {
+    const btn = document.querySelector('[data-gitgraph-chip-anchor] [data-gitgraph-chip]');
+    const cs = getComputedStyle(btn);
+    const r = btn.getBoundingClientRect();
+    return { minHeight: cs.minHeight, touchAction: cs.touchAction, fontSize: cs.fontSize, rect: { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) } };
+  })()`);
+  console.log('STYLES ' + JSON.stringify(styles));
+  // 2. pressed feedback via real mouse events
+  await send('Input.dispatchMouseEvent', { type: 'mousePressed', x: 60, y: 657, button: 'left', clickCount: 1 });
+  await sleep(120);
+  const pressed = await evaluate(`(() => { const btn = document.querySelector('[data-gitgraph-chip-anchor] [data-gitgraph-chip]'); const cs = getComputedStyle(btn); return { transform: cs.transform, active: btn.matches(':active') }; })()`);
+  console.log('PRESSED ' + JSON.stringify(pressed));
+  await send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: 60, y: 657, button: 'left', clickCount: 1 });
+  await sleep(2500);
+  const after = await evaluate(`(() => {
+    const p = document.querySelector('[data-gitgraph-popover]');
+    if (!p) return { popover: null };
+    const r = p.getBoundingClientRect();
+    return { popover: { y: Math.round(r.y), h: Math.round(r.height), inViewport: r.y >= 0 && r.bottom <= innerHeight }, options: document.querySelectorAll('[data-gitgraph-popover] [role="option"]').length };
+  })()`);
+  console.log('AFTER ' + JSON.stringify(after));
+  process.exit(0);
+}
+main().catch(e => { console.error('FATAL', e); process.exit(1); });

package/scripts/check-attach-upload.mjs

@@ -0,0 +1,99 @@
+// Self-check for the S7 attachment plumbing.
+//
+// The interesting logic is all string math now: the composer draft is the
+// feature's only state, so "which chips are showing" is entirely decided by
+// what mentionsIn() reads out of the draft text, and the × button is entirely
+// draftWithoutMention(). Both are exercised here, including the round trip
+// that the UI depends on (add N, remove them one by one, land back on '').
+//
+// S7.1 deleted the MIME-sorting assertions that used to live here: there is no
+// image/non-image split any more — every attachment takes the upload route.
+//
+// Run: node scripts/check-attach-upload.mjs   (needs Node >= 23.6 type stripping)
+import assert from 'node:assert/strict'
+import {
+  UPLOAD_DIR,
+  UPLOAD_ROUTE,
+  draftWithMention,
+  draftWithoutMention,
+  leafOf,
+  mentionsIn,
+  middleEllipsis,
+  uploadUrl,
+} from '../src/client/attach-upload.ts'
+
+// ---- the upload URL --------------------------------------------------------
+// Root-relative (so the gateway's pairing cookie rides along) and fully
+// escaped: a filename with a space, an ampersand, or CJK must not be able to
+// forge a second query parameter.
+assert.equal(uploadUrl('session-1', 'a.txt'), `${UPLOAD_ROUTE}?session=session-1&name=a.txt`)
+assert.equal(
+  uploadUrl('session-2', 'my notes&session=evil.txt'),
+  `${UPLOAD_ROUTE}?session=session-2&name=my+notes%26session%3Devil.txt`,
+)
+assert.equal(new URL(uploadUrl('s', '../../etc/passwd'), 'http://x').searchParams.get('name'), '../../etc/passwd')
+assert.equal(new URL(uploadUrl('s', '照片.jpg'), 'http://x').searchParams.get('name'), '照片.jpg')
+
+// ---- appending @mentions to the draft --------------------------------------
+const a = `${UPLOAD_DIR}/a.pdf`
+const b = `${UPLOAD_DIR}/b.zip`
+
+assert.equal(draftWithMention('', a), '@.dsh-uploads/a.pdf ')
+// A word already in the draft gets a separating space...
+assert.equal(draftWithMention('read', a), 'read @.dsh-uploads/a.pdf ')
+// ...but an existing trailing space or newline is not doubled.
+assert.equal(draftWithMention('read ', a), 'read @.dsh-uploads/a.pdf ')
+assert.equal(draftWithMention('read\n', a), 'read\n@.dsh-uploads/a.pdf ')
+// Two files in one pick stay in order and stay separated.
+assert.equal(draftWithMention(draftWithMention('', a), b), '@.dsh-uploads/a.pdf @.dsh-uploads/b.zip ')
+
+// ---- reading the chips back out of the draft -------------------------------
+assert.deepEqual(mentionsIn(''), [])
+assert.deepEqual(mentionsIn('just some prose'), [])
+assert.deepEqual(mentionsIn('@.dsh-uploads/a.pdf '), [a])
+// Reading order, with the user's own words interleaved.
+assert.deepEqual(mentionsIn('look at @.dsh-uploads/a.pdf and @.dsh-uploads/b.zip please'), [a, b])
+// A pasted duplicate must not produce two chips with the same React key.
+assert.deepEqual(mentionsIn('@.dsh-uploads/a.pdf @.dsh-uploads/a.pdf'), [a])
+// Other @-mentions (dsh-at-file's workspace references) are not ours.
+assert.deepEqual(mentionsIn('@src/index.ts @.dsh-uploads/a.pdf'), [a])
+// The directory name is matched literally — the `.` is not a wildcard.
+assert.deepEqual(mentionsIn('@Xdsh-uploads/a.pdf'), [])
+
+// ---- the × button ----------------------------------------------------------
+// Removing the only attachment leaves an empty draft, so the chip row and the
+// composer both go clean.
+assert.equal(draftWithoutMention('@.dsh-uploads/a.pdf ', a), '')
+// Removing one of two leaves the other, with no double space where it was.
+assert.equal(draftWithoutMention('@.dsh-uploads/a.pdf @.dsh-uploads/b.zip ', a), '@.dsh-uploads/b.zip ')
+assert.equal(draftWithoutMention('read @.dsh-uploads/a.pdf please', a), 'read please')
+// Prose survives even when it is the only thing left.
+assert.equal(draftWithoutMention('read @.dsh-uploads/a.pdf ', a), 'read ')
+// Removing something that is not there is a no-op.
+assert.equal(draftWithoutMention('read @.dsh-uploads/a.pdf ', b), 'read @.dsh-uploads/a.pdf ')
+
+// Full round trip: what the user sees after adding two and dismissing both.
+let draft = draftWithMention(draftWithMention('photos:', a), b)
+assert.deepEqual(mentionsIn(draft), [a, b])
+draft = draftWithoutMention(draft, a)
+assert.deepEqual(mentionsIn(draft), [b])
+draft = draftWithoutMention(draft, b)
+assert.deepEqual(mentionsIn(draft), [])
+// The separator space added before the first mention stays: the user is still
+// typing into this draft, and silently trimming under the caret is worse than
+// one trailing space.
+assert.equal(draft, 'photos: ')
+
+// ---- chip labels -----------------------------------------------------------
+assert.equal(leafOf(`${UPLOAD_DIR}/report.pdf`), 'report.pdf')
+assert.equal(leafOf('report.pdf'), 'report.pdf')
+// Short names are untouched; long ones lose their MIDDLE so the extension —
+// the part that says what the file IS — always survives.
+assert.equal(middleEllipsis('a.pdf'), 'a.pdf')
+const long = middleEllipsis('quarterly-revenue-breakdown-2026.pdf')
+assert.equal(long.length, 18)
+assert.ok(long.startsWith('quarterly'), long)
+assert.ok(long.endsWith('.pdf'), long)
+assert.ok(long.includes('…'))
+
+console.log('ATTACH UPLOAD CHECK OK')

package/scripts/check-sunk-viewport.mjs

@@ -0,0 +1,33 @@
+// Self-check for the iOS sunk-viewport detection (S1.2). No desktop browser
+// can enter that mode, so the boundary cases are asserted numerically instead.
+// Run: node scripts/check-sunk-viewport.mjs   (needs Node >= 23.6 type stripping)
+import assert from 'node:assert/strict'
+import { isViewportSunkBelowStatusBar as sunk } from '../src/client/effects/phone-chrome.ts'
+
+// The reported device: iPhone 393x852, standalone PWA, viewport already below
+// the status bar (852 - 793 = 59) while env still claims the full 59.
+assert.equal(sunk({ standalone: true, screenHeight: 852, innerHeight: 793, envTop: 59 }), true)
+
+// Same phone in a Safari tab -> never touch anything.
+assert.equal(sunk({ standalone: false, screenHeight: 852, innerHeight: 793, envTop: 59 }), false)
+
+// Standalone with black-translucent actually in effect: content is full-height,
+// so the inset is a real, un-paid-for offset and must stay.
+assert.equal(sunk({ standalone: true, screenHeight: 852, innerHeight: 852, envTop: 59 }), false)
+
+// Landscape iPhone: the notch moves to the sides, top inset is 0. The height
+// difference is large and meaningless -> the envTop guard rejects it.
+assert.equal(sunk({ standalone: true, screenHeight: 852, innerHeight: 350, envTop: 0 }), false)
+
+// Android standalone: loses status-bar height off innerHeight but reports no
+// top inset -> same guard, no change.
+assert.equal(sunk({ standalone: true, screenHeight: 2400, innerHeight: 2316, envTop: 0 }), false)
+
+// Notchless / desktop: nothing to compensate either way.
+assert.equal(sunk({ standalone: true, screenHeight: 800, innerHeight: 800, envTop: 0 }), false)
+
+// Partial sink (system ate less than the inset claims) is not this bug —
+// zeroing there would under-pad.
+assert.equal(sunk({ standalone: true, screenHeight: 852, innerHeight: 832, envTop: 59 }), false)
+
+console.log('SUNK VIEWPORT CHECK OK')

package/scripts/check-upload-endpoint.mjs

@@ -0,0 +1,168 @@
+// Integration check for the S7 upload route (src/index.ts handleUpload).
+//
+// Drives the real handler over a real node:http socket with a fake sessions
+// service and a throwaway workspace, so the accept/reject decisions and the
+// bytes that reach disk are the ones the phone would produce. No harness, no
+// session, no message: writing a file into a workspace is not a prompt.
+//
+// Run: node scripts/check-upload-endpoint.mjs   (needs Node >= 23.6 type stripping)
+import assert from 'node:assert/strict'
+import { createServer } from 'node:http'
+import { mkdtemp, mkdir, readFile, readdir, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { UPLOAD_DIR, handleUpload, safeUploadName, sameOriginPost } from '../src/index.ts'
+
+const MAX_BYTES = 4096
+
+const workspace = await mkdtemp(join(tmpdir(), 'mnav-upload-'))
+const outside = await mkdtemp(join(tmpdir(), 'mnav-outside-'))
+let logged = 0
+
+/** Minimal stand-in for the host Context the handler actually touches. */
+const ctx = {
+  sessions: {
+    get: (id) => (id === 'session-live' ? { header: { cwd: workspace } } : undefined),
+  },
+  logger: { warn: () => { logged += 1 } },
+}
+
+const server = createServer((req, res) => { void handleUpload(ctx, MAX_BYTES, req, res) })
+await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
+const base = `http://127.0.0.1:${server.address().port}`
+
+/** POST one body the way the browser does: raw bytes, same-origin headers. */
+async function post(query, body, init = {}) {
+  const response = await fetch(`${base}/_dsh/mobile-nav/upload${query}`, {
+    method: 'POST',
+    headers: { origin: base, 'content-type': 'application/octet-stream', ...(init.headers ?? {}) },
+    body,
+    duplex: 'half',
+    ...init,
+  })
+  return { status: response.status, body: await response.json() }
+}
+
+try {
+  // ---- pure helpers, before anything touches the disk ----------------------
+  // Path separators cannot survive; only the basename does.
+  assert.equal(safeUploadName('../../etc/passwd'), 'passwd')
+  assert.equal(safeUploadName('..\\..\\windows\\system32\\evil.dll'), 'evil.dll')
+  assert.equal(safeUploadName('/etc/shadow'), 'shadow')
+  // Dots and hyphens are ordinary filename characters and must be preserved
+  // (a character-class typo here silently mangles every extension).
+  assert.equal(safeUploadName('my-photo.2026.jpg'), 'my-photo.2026.jpg')
+  // Whitespace folds to _ so the client's @path mention stays one token.
+  assert.equal(safeUploadName('照片 (1).png'), '照片_(1).png')
+  assert.equal(safeUploadName('my  notes\tv2.txt'), 'my_notes_v2.txt')
+  assert.ok(!/\s/u.test(safeUploadName('a b c d.txt')))
+  // Dotfiles, empty labels, and Windows device names.
+  assert.equal(safeUploadName('...'), 'upload.bin')
+  assert.equal(safeUploadName(''), 'upload.bin')
+  assert.equal(safeUploadName('.bashrc'), 'bashrc')
+  assert.equal(safeUploadName('CON.txt'), '_CON.txt')
+  // Long names are capped in bytes, keeping the extension.
+  const long = safeUploadName(`${'あ'.repeat(200)}.jpg`)
+  assert.ok(Buffer.byteLength(long) <= 180, `long name still ${Buffer.byteLength(long)} bytes`)
+  assert.ok(long.endsWith('.jpg'))
+
+  // The gateway rewrites Origin/Host to the upstream origin, so a phone
+  // request presents as same-origin; a real cross-site POST does not.
+  assert.equal(sameOriginPost({ headers: { origin: 'http://127.0.0.1:3080', host: '127.0.0.1:3080' } }), true)
+  assert.equal(sameOriginPost({ headers: { origin: 'https://evil.example', host: '127.0.0.1:3080' } }), false)
+  assert.equal(sameOriginPost({ headers: { 'sec-fetch-site': 'cross-site' } }), false)
+  assert.equal(sameOriginPost({ headers: { 'sec-fetch-site': 'same-origin' } }), true)
+
+  // ---- happy path ----------------------------------------------------------
+  const payload = 'hello attachment\n'
+  const ok = await post('?session=session-live&name=notes.txt', payload)
+  assert.equal(ok.status, 201)
+  assert.equal(ok.body.ok, true)
+  assert.equal(ok.body.relPath, `${UPLOAD_DIR}/notes.txt`)
+  assert.equal(ok.body.bytes, Buffer.byteLength(payload))
+  assert.equal(await readFile(join(workspace, UPLOAD_DIR, 'notes.txt'), 'utf8'), payload)
+
+  // ---- same name twice does not clobber -----------------------------------
+  const again = await post('?session=session-live&name=notes.txt', 'second')
+  assert.equal(again.status, 201)
+  assert.equal(again.body.relPath, `${UPLOAD_DIR}/notes-1.txt`)
+  assert.equal(await readFile(join(workspace, UPLOAD_DIR, 'notes.txt'), 'utf8'), payload)
+
+  // ---- binary round-trip ---------------------------------------------------
+  const bytes = new Uint8Array(1024)
+  for (let i = 0; i < bytes.length; i += 1) bytes[i] = (i * 7) % 256
+  const bin = await post('?session=session-live&name=blob.bin', bytes)
+  assert.equal(bin.status, 201)
+  assert.deepEqual(new Uint8Array(await readFile(join(workspace, UPLOAD_DIR, 'blob.bin'))), bytes)
+
+  // ---- oversize, declared --------------------------------------------------
+  const tooBig = 'x'.repeat(MAX_BYTES + 1)
+  const declared = await post('?session=session-live&name=big.txt', tooBig)
+  assert.equal(declared.status, 413)
+  assert.equal(declared.body.error.code, 'too-large')
+
+  // ---- oversize, chunked (no Content-Length to pre-check) ------------------
+  const chunked = await post('?session=session-live&name=stream.txt', new ReadableStream({
+    start(controller) {
+      for (let i = 0; i < 5; i += 1) controller.enqueue(new TextEncoder().encode('y'.repeat(2048)))
+      controller.close()
+    },
+  }))
+  assert.equal(chunked.status, 413)
+  assert.equal(chunked.body.error.code, 'too-large')
+
+  // ---- path traversal ------------------------------------------------------
+  const escape = await post('?session=session-live&name=..%2F..%2Fevil.txt', 'nope')
+  assert.equal(escape.status, 201, 'the name is sanitized, not rejected')
+  assert.equal(escape.body.relPath, `${UPLOAD_DIR}/evil.txt`)
+  assert.equal(await readFile(join(workspace, UPLOAD_DIR, 'evil.txt'), 'utf8'), 'nope')
+  // Nothing at all escaped into the parent of the workspace.
+  assert.deepEqual(await readdir(outside), [])
+
+  // ---- unknown session -----------------------------------------------------
+  const ghost = await post('?session=session-gone&name=a.txt', 'x')
+  assert.equal(ghost.status, 404)
+  assert.equal(ghost.body.error.code, 'session-not-found')
+
+  // ---- malformed query -----------------------------------------------------
+  assert.equal((await post('?name=a.txt', 'x')).status, 400)
+  assert.equal((await post('?session=session-live', 'x')).status, 400)
+  assert.equal((await post('?session=a&session=b&name=x.txt', 'x')).status, 400)
+
+  // ---- method and origin ---------------------------------------------------
+  const wrongMethod = await fetch(`${base}/_dsh/mobile-nav/upload?session=session-live&name=a.txt`)
+  assert.equal(wrongMethod.status, 405)
+  const crossSite = await post('?session=session-live&name=a.txt', 'x', {
+    headers: { origin: 'https://evil.example' },
+  })
+  assert.equal(crossSite.status, 403)
+  assert.equal(crossSite.body.error.code, 'origin-rejected')
+
+  // ---- a symlinked upload directory is refused, not followed ---------------
+  const trapWorkspace = await mkdtemp(join(tmpdir(), 'mnav-trap-'))
+  await mkdir(join(outside, 'loot'), { recursive: true })
+  await symlink(join(outside, 'loot'), join(trapWorkspace, UPLOAD_DIR))
+  ctx.sessions.get = (id) => (id === 'session-trap' ? { header: { cwd: trapWorkspace } } : undefined)
+  const trapped = await post('?session=session-trap&name=a.txt', 'x')
+  assert.equal(trapped.status, 400)
+  assert.equal(trapped.body.error.code, 'path-escape')
+  assert.deepEqual(await readdir(join(outside, 'loot')), [])
+  await rm(trapWorkspace, { recursive: true, force: true })
+
+  // Every rejection that reached the body is logged once, so a failing phone
+  // leaves a trail: 2x413, 404, 3x400 query, 1x400 symlink. The 405 and 403
+  // short-circuit before the try block and deliberately log nothing — they are
+  // the two an unpaired scanner can trigger at will.
+  assert.equal(logged, 7, `expected the rejections to be logged, saw ${logged}`)
+
+  // ---- the workspace holds exactly what was uploaded, nothing partial ------
+  assert.deepEqual((await readdir(join(workspace, UPLOAD_DIR))).sort(), [
+    'blob.bin', 'evil.txt', 'notes-1.txt', 'notes.txt',
+  ])
+
+  console.log('UPLOAD ENDPOINT CHECK OK')
+} finally {
+  await new Promise((resolve) => server.close(resolve))
+  await rm(workspace, { recursive: true, force: true })
+  await rm(outside, { recursive: true, force: true })
+}

package/src/client/MobileAttachButton.tsx

@@ -0,0 +1,125 @@
+import { useRef, useState } from 'react'
+import type { ChangeEvent } from 'react'
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
+import { IconPaperclipOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
+import { NS } from './locales.ts'
+import { draftWithMention, rememberThumbnail, uploadUrl } from './attach-upload.ts'
+
+/** Full props for the composer attachment seat. */
+export type MobileAttachButtonProps =
+  & PropsRuntime<'conversation.input.left'>
+  & PropsLocale<typeof NS>
+
+/** Shape of the node half's response body (src/index.ts handleUpload). */
+type UploadResult = { ok: true; relPath: string } | { ok: false; error: { code: string; message: string } }
+
+/** Post one file to the host route and return the workspace-relative path it landed on. */
+async function uploadFile(sessionId: SessionId, file: File): Promise<string> {
+  const response = await fetch(uploadUrl(sessionId, file.name), {
+    method: 'POST',
+    // Same-origin so the gateway half of this plugin's pairing cookie rides along;
+    // the body is the raw bytes, no multipart wrapper for the host to parse.
+    credentials: 'same-origin',
+    headers: { 'Content-Type': file.type === '' ? 'application/octet-stream' : file.type },
+    body: file,
+  })
+  const body = (await response.json()) as UploadResult
+  if (!response.ok || !body.ok) {
+    throw new Error(body.ok === false ? body.error.message : `HTTP ${response.status}`)
+  }
+  return body.relPath
+}
+
+/**
+ * Composer attachment button (S7).
+ *
+ * Renders into `conversation.input.left`, which CSS orders to the leftmost
+ * seat of the phone composer's bottom row (and hides at >= 768px, where the
+ * official picker on the host machine is the right answer). Tapping it opens
+ * the CLIENT's picker — no `accept` attribute on purpose, so iOS offers the
+ * full 相册 / 拍照 / 选取文件 sheet rather than one of them.
+ *
+ * Every picked file takes the SAME path: upload to the node half, then append
+ * `@.dsh-uploads/name` to the draft through `inputActions.setDraft` (the
+ * official write path — no DOM value poking). S7.1 removed the split that used
+ * to send inlineable images straight into the session with `session.prompt`:
+ * one behaviour for every attachment, and the user always presses send.
+ * MobileAttachChips renders the preview row off those same draft tokens.
+ *
+ * Files upload one at a time: a phone uplink gains nothing from parallelism
+ * and a serial loop keeps the mentions in pick order.
+ */
+export function MobileAttachButton({ t, sessionId, useInput, inputActions }: MobileAttachButtonProps) {
+  const picker = useRef<HTMLInputElement>(null)
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const draft = useInput((state) => state.draft)
+  // Uploads are awaited, so the `draft` captured at pick time goes stale — the
+  // user can keep typing while a file is in flight. The ref is refreshed on
+  // every render (useInput re-renders us on each draft change), so the loop
+  // below can rebase onto whatever the composer holds right now.
+  const liveDraft = useRef(draft)
+  liveDraft.current = draft
+
+  const pick = async (event: ChangeEvent<HTMLInputElement>) => {
+    const files = Array.from(event.target.files ?? [])
+    // Reset first: picking the same file twice in a row fires no change event
+    // otherwise, which reads to the user as "the button stopped working".
+    event.target.value = ''
+    if (files.length === 0) return
+
+    setBusy(true)
+    setError(null)
+    // setDraft takes the WHOLE next draft, so each mention is appended to the
+    // value we last wrote — unless the ref shows the user has typed since, in
+    // which case theirs wins and we append to that instead. (Rebasing on the
+    // ref unconditionally would lose a mention whenever React had not yet
+    // re-rendered us between two files of the same pick.)
+    let written = liveDraft.current
+    try {
+      for (const file of files) {
+        const relPath = await uploadFile(sessionId, file)
+        // Local preview for the chip row; a no-op for non-images.
+        rememberThumbnail(relPath, file)
+        written = draftWithMention(liveDraft.current === written ? written : liveDraft.current, relPath)
+        inputActions.setDraft(written)
+      }
+    } catch (cause) {
+      setError(cause instanceof Error ? cause.message : String(cause))
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  return (
+    <>
+      <input
+        ref={picker}
+        type="file"
+        multiple
+        data-mobile-nav="attach-picker"
+        onChange={(event) => { void pick(event) }}
+      />
+      <button
+        type="button"
+        data-mobile-nav="attach"
+        data-busy={busy ? '' : undefined}
+        aria-label={t('attach')}
+        aria-busy={busy}
+        title={error ?? (busy ? t('attachBusy') : t('attach'))}
+        onClick={() => {
+          setError(null)
+          picker.current?.click()
+        }}
+      >
+        <IconPaperclipOutline16 size={16} />
+        {error === null ? null : (
+          <span data-mobile-nav="attach-error" role="status" onClick={(e) => { e.stopPropagation(); setError(null) }}>
+            {t('attachFailed')}
+          </span>
+        )}
+      </button>
+    </>
+  )
+}

package/src/client/MobileAttachChips.tsx

@@ -0,0 +1,85 @@
+import { useEffect } from 'react'
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
+import { IconCloseFill14, IconPaperclipOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+import { NS } from './locales.ts'
+import {
+  draftWithoutMention,
+  leafOf,
+  mentionsIn,
+  middleEllipsis,
+  releaseThumbnailsExcept,
+  thumbnailFor,
+} from './attach-upload.ts'
+
+/** Full props for the attachment preview row. */
+export type MobileAttachChipsProps =
+  & PropsRuntime<'conversation.input.dock'>
+  & PropsLocale<typeof NS>
+
+/**
+ * Attachment preview row (S7.1), in `conversation.input.dock` — the official
+ * full-width row above the composer card, which composer.css.ts already lays
+ * out as one horizontally scrollable chip line shared with whatever else docks
+ * there (the git branch chip, a todo strip). No DOM injection into the
+ * official card.
+ *
+ * **This component owns no state.** It renders whatever
+ * `@.dsh-uploads/...` tokens the draft currently holds, so:
+ *
+ * - uploading appends a token -> a chip appears;
+ * - the × removes the token -> the chip disappears;
+ * - the user hand-deleting the text -> the chip disappears;
+ * - the official send clearing the draft -> every chip disappears.
+ *
+ * There is no list to keep in sync and nothing to reconcile on session switch.
+ * The only side state is the preview-URL map in attach-upload.ts, and the
+ * effect below is what keeps it honest: anything no longer mentioned gets its
+ * object URL revoked.
+ *
+ * An image chip is a 48px tile; anything else (and any image whose preview did
+ * not survive, see below) is a name pill. The `<img>` is stacked ON TOP of the
+ * paperclip rather than swapped for it, so a format the engine cannot decode —
+ * HEIC everywhere except WebKit — just fails to paint and reveals the icon,
+ * with no error state to track.
+ */
+export function MobileAttachChips({ t, useInput, inputActions }: MobileAttachChipsProps) {
+  const draft = useInput((state) => state.draft)
+  const attachments = mentionsIn(draft)
+
+  useEffect(() => {
+    releaseThumbnailsExcept(mentionsIn(draft))
+  }, [draft])
+
+  if (attachments.length === 0) return null
+
+  return (
+    <div data-mobile-nav="attach-chips">
+      {attachments.map((relPath) => {
+        const name = leafOf(relPath)
+        const preview = thumbnailFor(relPath)
+        return (
+          <span
+            key={relPath}
+            data-mobile-nav="attach-chip"
+            data-kind={preview === undefined ? 'file' : 'image'}
+            title={name}
+          >
+            <span data-mobile-nav="attach-chip-art">
+              <IconPaperclipOutline16 size={16} />
+              {preview === undefined ? null : <img src={preview} alt="" />}
+            </span>
+            {preview === undefined ? <span data-mobile-nav="attach-chip-name">{middleEllipsis(name)}</span> : null}
+            <button
+              type="button"
+              data-mobile-nav="attach-chip-remove"
+              aria-label={t('attachRemove', { name })}
+              onClick={() => inputActions.setDraft(draftWithoutMention(draft, relPath))}
+            >
+              <IconCloseFill14 size={14} />
+            </button>
+          </span>
+        )
+      })}
+    </div>
+  )
+}

package/src/client/MobileDrawerFooter.tsx

@@ -0,0 +1,56 @@
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
+import { IconDownloadOutline16, IconPanelLeftOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+import { NS } from './locales.ts'
+
+/** Full props for the sidebar footer action entry. */
+export interface MobileDrawerFooterProps extends PropsRuntime<'sidebar.footer.action'>, PropsLocale<typeof NS> {
+  /** Bound ctx.sessionLogDownload.download() for the current session. */
+  downloadSessionLog: (sessionId: string) => void
+  /** Bound ctx.layout.toggleSidebar(): the Files sheet closes the drawer. */
+  toggleSidebar: () => void
+}
+
+/**
+ * Mobile-only drawer footer actions, relocated from the session header to the
+ * drawer footer (beside Settings):
+ * - Files: opens the dsh-web-ui aionui explorer as a floating bottom sheet
+ *   (the explorer column is hidden on mobile until this marker is set, so
+ *   the suite's own persisted-expanded state can never cover the UI on load).
+ * - Session log: the official session-log-export controller, so the
+ *   progress/result dialog is shared with the desktop flow.
+ * Hidden entirely on wide screens (CSS media query).
+ */
+export function MobileDrawerFooter({ useSessions, downloadSessionLog, toggleSidebar, t }: MobileDrawerFooterProps) {
+  const sessionId = useSessions((state) => state.current)
+  const openExplorer = (): void => {
+    document.querySelector('[data-mobile-nav="frame"]')?.setAttribute('data-aionui-explorer-open', '')
+    toggleSidebar()
+  }
+  return (
+    <div data-mobile-nav="drawer-actions">
+      <button
+        type="button"
+        data-mobile-nav="explorer"
+        aria-label={t('files')}
+        title={t('files')}
+        onClick={openExplorer}
+      >
+        <IconPanelLeftOutline16 size={14} />
+        <span>{t('files')}</span>
+      </button>
+      <button
+        type="button"
+        data-mobile-nav="session-log"
+        aria-label={t('sessionLog')}
+        title={t('sessionLog')}
+        disabled={sessionId === undefined}
+        onClick={() => {
+          if (sessionId !== undefined) downloadSessionLog(sessionId)
+        }}
+      >
+        <IconDownloadOutline16 size={14} />
+        <span>{t('sessionLog')}</span>
+      </button>
+    </div>
+  )
+}