From 0b3087918fe431c8060de7f561722bf577575198 Mon Sep 17 00:00:00 2001 From: ArizeSky <97787713+ArizeSky@users.noreply.github.com> Date: Sun, 15 Nov 2026 14:26:12 +0800 Subject: [PATCH] fix(deepseek): make the Harness web tab render, not just authenticate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `dsh web` gates its own index behind a per-process launch token it prints on boot, and only that URL mints the `dsh-auth-*` cookie every later request needs. The managed tab stores the clean URL, so nothing on the browser side could present the token: the iframe rendered dsh's 401 text, a blank tab. Read the token out of the captured boot output, trade it for the cookie once at startup (`redirect: 'manual'`, since the 303 is what carries Set-Cookie), and let the proxy present it on both the HTTP and WebSocket legs. Scoped to the exact loopback authority the cookie was minted for; a token-less banner (an older dsh) keeps the previous behaviour untouched. The banner is scanned on its own 256 KB budget rather than the 16 KB error-tail buffer: a chatty profile can fill that cap before the banner prints. Authentication alone was not enough. dsh ships ``, which a browser resolves against the DOCUMENT url — and the proxy's runtime shim rewrites that url to strip the `/webview//` prefix. The base therefore landed on Codeman's root: every module script 404'd and the page painted its inline `#151517` background with nothing on it (the black screen that replaced the white one). `rewriteHtml` now resolves a relative base against the proxy prefix before the mask can run, leaving a cross-origin base exactly as written. Verified against dsh 0.2.1-rc.5 and a live Codeman build: bare GET 401, captured cookie 200, proxied `/api` WebSocket 101, and a headless-Chrome load of the proxied tab boots the full Harness UI with no console errors. --- .changeset/dsh-web-launch-token.md | 5 + .changeset/webview-relative-base.md | 5 + docs/deepseek-integration.md | 12 +++ src/deepseek-web-server.ts | 160 +++++++++++++++++++++++++++- src/web/routes/webview-routes.ts | 36 ++++++- src/web/webview-proxy.ts | 67 +++++++++++- test/deepseek-web-server.test.ts | 158 ++++++++++++++++++++++++++- test/webview-proxy.test.ts | 40 +++++++ 8 files changed, 474 insertions(+), 9 deletions(-) create mode 100644 .changeset/dsh-web-launch-token.md create mode 100644 .changeset/webview-relative-base.md diff --git a/.changeset/dsh-web-launch-token.md b/.changeset/dsh-web-launch-token.md new file mode 100644 index 00000000..6fc62748 --- /dev/null +++ b/.changeset/dsh-web-launch-token.md @@ -0,0 +1,5 @@ +--- +"aicodeman": patch +--- + +The DeepSeek Harness web tab opens on the dashboard again instead of a blank 401 page. `dsh web` now gates its own index behind a one-time launch token it prints on boot; the supervisor reads that token out of the captured output, trades it for the session cookie once at startup, and the webview proxy presents the cookie on both the HTTP and WebSocket legs — scoped to the loopback authority it was minted for. A dsh without the gate keeps working unchanged. diff --git a/.changeset/webview-relative-base.md b/.changeset/webview-relative-base.md new file mode 100644 index 00000000..1698d9ec --- /dev/null +++ b/.changeset/webview-relative-base.md @@ -0,0 +1,5 @@ +--- +"aicodeman": patch +--- + +Web tabs whose dashboard ships a relative `` render again. The proxy rewrites the document URL to strip its `/webview//` prefix, and a relative base is resolved against that URL — so `./` (what Vite builds emit, DeepSeek Harness among them) pointed at Codeman's root: every module script 404'd and the page painted its background with nothing on it. The rewrite now resolves such a base against the proxy prefix before the mask runs; a cross-origin base is left exactly as the author wrote it. diff --git a/docs/deepseek-integration.md b/docs/deepseek-integration.md index 02af1002..834054c7 100644 --- a/docs/deepseek-integration.md +++ b/docs/deepseek-integration.md @@ -288,6 +288,18 @@ dsh fences its `/api` behind a browser-trust check on the request authority, and Codeman web tab reaches it through Codeman's own origin via the webview proxy, not directly. Without it the page renders and every API call fails. +Since dsh's browser-auth gate, the index is not public either: boot prints +`dsh web: http://127.0.0.1:/?token=` and only a request +carrying that token is answered with the `dsh-auth-*` cookie that authorizes +everything after it. The saved tab deliberately keeps the clean URL, so the +browser can never present that token, and the tab used to open on dsh's 401 page. +`src/deepseek-web-server.ts` now reads the token out of the captured boot output, +trades it for the cookie once at startup, and `webview-routes.ts` presents that +cookie on both the HTTP and WebSocket legs — scoped to the exact loopback +authority it was minted for, so a repointed or stale tab cannot carry it +elsewhere. A dsh without the gate prints a token-less banner and keeps working +unchanged. + ## 7. Docker and remote cases Docker cases work: the agent image installs `dsh` and bootstraps a `dsh-tui` diff --git a/src/deepseek-web-server.ts b/src/deepseek-web-server.ts index 78dbf961..7520fb4f 100644 --- a/src/deepseek-web-server.ts +++ b/src/deepseek-web-server.ts @@ -27,6 +27,11 @@ * - **Failures reported, not swallowed.** The shell tab used to be where the * stack trace landed. With no tab, the spawn's own output is captured and * handed back to the caller instead. + * - **The launch token traded, not forwarded.** `dsh web` gates its own index + * behind a one-time token it prints on stdout and exchanges for a browser + * cookie. The tab stores a clean URL, so nothing on the browser side could + * ever present that token and every load answered 401. This module trades it + * here, once, and hands the cookie to the proxy (`getDeepSeekWebCookie`). */ import { spawn, type ChildProcess } from 'node:child_process'; @@ -53,6 +58,23 @@ const READY_POLL_MS = 400; const KILL_GRACE_MS = 3_000; /** Bound on captured child output, so a chatty boot cannot grow without limit. */ const OUTPUT_CAP = 16_384; +/** + * Bound on the boot-output window searched for the launch banner. + * + * Deliberately larger and separate from {@link OUTPUT_CAP}: that one only has to + * keep an error tail, while this one must survive a chatty plugin tree's boot + * logs long enough to see a banner printed after them. 256 KB of one-line output + * is far beyond anything a real boot prints, and a bound still exists because a + * wedged child can print forever. + */ +const BANNER_SCAN_CAP = 262_144; + +/** How long boot waits for `dsh web` to print the launch URL it gates itself on. */ +const LAUNCH_URL_WAIT_MS = 4_000; +/** Bound on the one-shot token→cookie exchange (loopback, so this is generous). */ +const TOKEN_EXCHANGE_TIMEOUT_MS = 5_000; +/** Cookie name `dsh web` mints for a browser session that presented the token. */ +const DSH_AUTH_COOKIE_PREFIX = 'dsh-auth-'; export interface DeepSeekWebStatus { running: boolean; @@ -67,6 +89,18 @@ interface RunningServer { port: number; authority: string; output: () => string; + /** + * Boot output scanned for the launch banner, on its own (larger) budget than + * `output`. Read through this rather than `output` so a banner printed after + * the error-tail cap filled is still found. + */ + banner: () => string; + /** + * The `dsh-auth-*` cookie bought with this process's launch token, once the + * exchange succeeded. Null on a dsh old enough to serve its index without a + * token, which is why "no cookie" is not a startup failure. + */ + cookie: string | null; } let current: RunningServer | null = null; @@ -105,6 +139,101 @@ async function answersHttp(port: number): Promise { } } +/** + * The authenticated URL `dsh web` prints once it is up. + * + * Its browser-auth gate made the index private: boot writes + * `dsh web: http://127.0.0.1:/?token=` and only a request + * carrying that token is answered with the cookie that authorizes everything + * after it. The token is per process, so it can be neither guessed nor carried + * across restarts — it has to be read out of the boot output. + * + * Null for output without one, which is the older-dsh case and stays working. + * + * @param output - captured stdout+stderr so far. + * @returns absolute http(s) URL carrying a `token`, or null. + */ +export function parseLaunchUrl(output: string): string | null { + // Strip SGR sequences first: a coloured banner would otherwise hide the URL + // behind escape codes and turn a perfectly working server into a 401. Built + // from the code point rather than written as `\x1b` so the linter's + // no-control-regex rule does not read it as an accidental control character. + const plain = output.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g'), ''); + const match = /dsh web:\s*(\S+)/.exec(plain); + if (!match) return null; + let url: URL; + try { + url = new URL(match[1]); + } catch { + return null; + } + if (url.protocol !== 'http:' && url.protocol !== 'https:') return null; + return url.searchParams.get('token') ? url.href : null; +} + +/** + * Trade the launch URL for the `dsh-auth-*` cookie the proxy will present. + * + * `redirect: 'manual'` is load-bearing: the 303 is the response that carries + * `Set-Cookie`, and following it would burn the token on a redirect to `./` + * while dropping the only credential the exchange produces. + * + * @param launchUrl - token-bearing URL from {@link parseLaunchUrl}. + * @returns `name=value` pair ready for a Cookie header, or null. + */ +async function exchangeLaunchToken(launchUrl: string): Promise { + try { + const response = await fetch(launchUrl, { + redirect: 'manual', + signal: AbortSignal.timeout(TOKEN_EXCHANGE_TIMEOUT_MS), + }); + for (const header of response.headers.getSetCookie()) { + const pair = header.split(';', 1)[0]?.trim(); + if (pair?.startsWith(DSH_AUTH_COOKIE_PREFIX)) return pair; + } + return null; + } catch { + return null; + } +} + +/** + * Wait for the banner, then exchange it. + * + * Never fails startup: a dsh without the gate prints a token-less banner, which + * is answered as "nothing to exchange" immediately rather than after the whole + * wait, and a gate that changes shape must not turn a serving UI into a boot + * failure. + * + * @param running - the just-started server, read for its captured output. + * @returns the cookie to hand the proxy, or null. + */ +async function captureSessionCookie(running: RunningServer): Promise { + const deadline = Date.now() + LAUNCH_URL_WAIT_MS; + while (Date.now() < deadline) { + const banner = running.banner(); + const launchUrl = parseLaunchUrl(banner); + if (launchUrl) { + const cookie = await exchangeLaunchToken(launchUrl); + // The URL is a credential: never log it, only the fact that it did not work. + if (!cookie) { + console.warn( + '[DeepSeek web] the launch token was printed but could not be exchanged for a session cookie; ' + + "the tab will show dsh's 401 page until `dsh web` is restarted" + ); + } + return cookie; + } + // Only a printed http(s) URL settles this: it is the older dsh, which needs + // no cookie. Any other line carrying the prefix (a diagnostic, a truncated + // write) is not a banner, so the wait continues instead of giving up early. + const printed = /dsh web:\s*(\S+)/.exec(banner)?.[1]; + if (printed && /^https?:\/\//.test(printed)) return null; + await new Promise((resolve) => setTimeout(resolve, 100)); + } + return null; +} + /** * Signal the whole process group. * @@ -134,6 +263,22 @@ export function getDeepSeekWebStatus(): DeepSeekWebStatus { }; } +/** + * The cookie this server's launch token bought, for the proxy to present. + * + * Keyed by `port` because the cookie is signed for the authority it was minted + * under (`127.0.0.1:`): handing it to a web tab pointed at some other + * server would neither authenticate nor be that server's to receive. Null also + * covers a dsh old enough to need no cookie at all. + * + * @param port - loopback port the upstream request is bound for. + * @returns `name=value` cookie pair, or null. + */ +export function getDeepSeekWebCookie(port: number): string | null { + if (!current || current.port !== port) return null; + return current.cookie; +} + /** Stop the background server, if one is running. Safe to call when none is. */ export async function stopDeepSeekWeb(): Promise { const running = current; @@ -223,8 +368,15 @@ async function startDeepSeekWebLocked(dshDir: string, authority: string): Promis // The pipes must be drained whether or not anyone reads them: a full pipe // blocks the child. Storage is capped; draining is not. let output = ''; + // Scanned for the launch banner separately from `output`. That cap exists to + // bound the error tail, and a chatty profile can fill it before the banner is + // printed — losing the banner there produces exactly the 401 tab this module + // exists to prevent, so the two buffers must not share a limit. + let banner = ''; const capture = (chunk: Buffer) => { - if (output.length < OUTPUT_CAP) output += chunk.toString('utf-8'); + const text = chunk.toString('utf-8'); + if (output.length < OUTPUT_CAP) output += text; + if (banner.length < BANNER_SCAN_CAP) banner += text; }; child.stdout?.on('data', capture); child.stderr?.on('data', capture); @@ -241,7 +393,7 @@ async function startDeepSeekWebLocked(dshDir: string, authority: string): Promis if (current?.child === child) current = null; }); - const running: RunningServer = { child, port, authority, output: () => output }; + const running: RunningServer = { child, port, authority, output: () => output, banner: () => banner, cookie: null }; current = running; const deadline = Date.now() + READY_TIMEOUT_MS; @@ -255,6 +407,10 @@ async function startDeepSeekWebLocked(dshDir: string, authority: string): Promis return { ok: false, error: tail ? `dsh web exited during startup: ${tail}` : 'dsh web exited during startup' }; } if (await answersHttp(port)) { + // Bought before this call resolves, so the first proxied page load + // already carries a credential — a tab opened a moment earlier would + // otherwise get the 401 this whole module exists to prevent. + running.cookie = await captureSessionCookie(running); return { ok: true, port, url: `http://127.0.0.1:${port}`, reused: false }; } await new Promise((r) => setTimeout(r, READY_POLL_MS)); diff --git a/src/web/routes/webview-routes.ts b/src/web/routes/webview-routes.ts index 579aada5..2cd5bc43 100644 --- a/src/web/routes/webview-routes.ts +++ b/src/web/routes/webview-routes.ts @@ -50,6 +50,7 @@ import { readWebviews, writeWebviews } from '../../webview-store.js'; import { webviewCapabilities } from '../../webview-capabilities.js'; import { egressBlockedReason, webviewEgressLookup, webviewFetch, type EgressLookup } from '../webview-egress.js'; import { blockedWebviewHostReason } from '../webview-egress-policy.js'; +import { getDeepSeekWebCookie } from '../../deepseek-web-server.js'; import { ApiErrorCode, createErrorResponse } from '../../types.js'; import type { Webview, WebviewOpenData, WebviewProbe } from '../../types.js'; import { AUTH_COOKIE_NAME } from '../middleware/auth.js'; @@ -426,6 +427,31 @@ function proxyHttp( return proxyRequest(req, reply, req.params.cap, req.params['*'] ?? '', basePath); } +/** + * The credential a Codeman-managed dashboard needs on every upstream request. + * + * `dsh web` now gates its index and `/api` behind a cookie minted for the + * authority it was started on, and only the URL it prints on boot carries the + * token that buys it. The managed DeepSeek tab deliberately stores the clean + * URL, so the browser can never hold that cookie: `deepseek-web-server.ts` + * exchanges the token at startup, and this is where the supervisor's result + * reaches the request. + * + * Strictly scoped to the exact loopback origin the cookie was minted for. A + * web tab the user repointed at another host, or a stale tab still naming a + * previous port, must not be handed a credential that is not its own. + * + * @param webview - the saved tab being proxied. + * @param upstream - resolved upstream URL for this request. + * @returns `name=value` cookie pair, or undefined when none applies. + */ +function managedDashboardCookie(webview: Webview, upstream: URL): string | undefined { + if (webview.managed !== 'deepseek-web') return undefined; + if (upstream.hostname !== '127.0.0.1') return undefined; + const port = Number(upstream.port || (upstream.protocol === 'https:' ? 443 : 80)); + return getDeepSeekWebCookie(port) ?? undefined; +} + /** * Proxy one request to the dashboard behind `cap`, serving `wildcard` as the * upstream path. Split out from the route handler so the 404 fallback (which has @@ -468,12 +494,14 @@ async function proxyRequest( } const hasBody = req.method !== 'GET' && req.method !== 'HEAD'; + const injectedCookie = managedDashboardCookie(webview, upstream); const headers = buildUpstreamRequestHeaders(req.headers, upstream, { forwardCookies: webview.trusted, sessionCookieName: AUTH_COOKIE_NAME, refererPath: typeof req.headers.referer === 'string' ? stripProxyPrefix(req.headers.referer, cap, basePath) : undefined, relayBodyLength: hasBody && req.body !== undefined, + ...(injectedCookie ? { injectedCookie } : {}), }); // #237: the timeout bounds TIME-TO-HEADERS only. A plain AbortSignal.timeout on @@ -707,13 +735,19 @@ function proxyWebSocket(socket: WebSocket, req: FastifyRequest<{ Params: ProxyPa }; const protocols = req.headers['sec-websocket-protocol']; + // The same credential the HTTP leg presents. A managed dashboard's realtime + // channel is gated exactly like its index, so without this the page loads + // and then sits there silently disconnected. + const cookie = + managedDashboardCookie(webview, upstream) ?? + (webview.trusted && req.headers.cookie ? String(req.headers.cookie) : undefined); // `lookup` is absent from ws's ClientOptions typings but flows through // http.request to net.connect untouched, which is where the resolved // address is judged (see webview-egress.ts). const upstreamOptions: WsClientOptions & { lookup: EgressLookup } = { headers: { origin: upstream.origin, - ...(webview.trusted && req.headers.cookie ? { cookie: String(req.headers.cookie) } : {}), + ...(cookie ? { cookie } : {}), }, handshakeTimeout: WEBVIEW_WS_HANDSHAKE_TIMEOUT_MS, lookup: webviewEgressLookup, diff --git a/src/web/webview-proxy.ts b/src/web/webview-proxy.ts index bc05feed..45b7ca16 100644 --- a/src/web/webview-proxy.ts +++ b/src/web/webview-proxy.ts @@ -311,7 +311,19 @@ export function filterCookieHeader(cookie: string | undefined, drop: string[]): export function buildUpstreamRequestHeaders( incoming: Record, upstream: URL, - opts: { forwardCookies: boolean; sessionCookieName: string; refererPath?: string; relayBodyLength?: boolean } + opts: { + forwardCookies: boolean; + sessionCookieName: string; + refererPath?: string; + relayBodyLength?: boolean; + /** + * A credential the SERVER holds for this dashboard, replacing whatever the + * browser sent. `dsh web` mints its session cookie for a loopback authority + * the browser never visits, so the proxy is the only party that can present + * it (see `deepseek-web-server.ts`). + */ + injectedCookie?: string; + } ): Record { const headers: Record = {}; @@ -343,6 +355,11 @@ export function buildUpstreamRequestHeaders( if (cookie) headers['cookie'] = cookie; } + // After the relay above, so a browser copy can never shadow it: these cookies + // are scoped to the browser's origin, and the authority this request is for is + // one it has never been able to store anything against. + if (opts.injectedCookie) headers['cookie'] = opts.injectedCookie; + // Present as if the browser were talking to the dashboard directly. Apps that // check Origin on writes (CSRF defenses) need this to match their own origin. headers['origin'] = upstream.origin; @@ -646,6 +663,45 @@ try{ }catch(e){}})();`; } +/** + * Make a page's own RELATIVE `` absolute under the proxy prefix. + * + * A base element is resolved against the document's URL, and {@link runtimeUrlShim} + * deliberately rewrites that URL to strip the proxy prefix. So a page shipping + * `` — which is what a Vite build does, DeepSeek Harness among + * them — has its base re-resolved to Codeman's ROOT the moment the shim runs: + * every module script, stylesheet and `fetch('./api')` then asks the Codeman + * origin instead of the dashboard. The visible symptom is not an error page but + * a blank one: the markup and inline `