figmar/apes-sidebar
1
0
Fork 0
Code Issues 1 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat!: move to the alpha track — DSH 0.1.2-alpha.x only (v0.18.0-alpha.0)

Browse Source 
DSH itself is still on its 0.1.2-alpha line (npm `alpha` dist-tag), so the
plugin mirrors it: v0.18.0-alpha.0 publishes under the npm `alpha`
dist-tag and supports DSH 0.1.2-alpha.x only. Stable-DSH (0.1.0-rc.8 ~
0.1.1-rc.2) users stay on v0.17.1 (npm `latest`). Verified end-to-end
against a real 0.1.2-alpha.2 host: full vitest suite, typecheck,
build/pack, consumer type surface, and the headless mount smoke 14/14
(the prerelease version also passes `dsh plugin add file:`).

- peer floor raised `^0.1.0-rc.8` -> `^0.1.2-alpha.2` (the mount install
  no longer warns: the old floor could not semver-match a prerelease
  host); dsh.plugin.json engines.dsh `>=0.1.2-alpha.2`.
- Dropped the pre-alpha compatibility layer:
  - e2e host RPC collapsed from the dot/slash dual dialect to slash-only
    (rpcAttempt; the 404-probe negotiation and its cache are gone), and
    parseLaunchUrl now requires the ?token= launch URL;
  - MarkdownText labels collapsed to the nested single shape (the cast
    became unnecessary against the alpha.2 declarations);
  - the defunct `@deepseek-ai/dsh-client-runtime` row is gone from the
    chunk externals allowlist (chunk-loader / tsdown / two specs) and
    from dsh.client.inject.
- market-manifest guard now allows an exact prerelease version (alpha
  cuts are not the market's verified `latest` target); release.yml picks
  the npm dist-tag from the version (prerelease -> `alpha`, else
  `latest`) so an alpha can never hijack `latest`.
- Docs retargeted: AGENTS.md §2/§3, README/README_EN badges + v0.18.0
  -alpha.0 section + install note (`dsh-better-sidebar@alpha`), guide.
This commit is contained in:
Menghuan1918
2026-08-30 23:42:16 +08:00
parent f9e00bb0d0
commit 07eebbbad0
17 changed files with 222 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/e2e/host.ts
+42 -62
View File
@@ -1,21 +1,18 @@
/**
* Host glue for the e2e lanes: page/asset URL construction, the authenticated
* request context, and the dual-protocol host RPC. The cross-version shapes
* (bare origin vs one-time-token URL, dot vs slash `/api` endpoints) live in
* ./host-protocol.ts; this module only wires them to Playwright.
* request context, and the host RPC. The transport contracts (one-time-token
* launch URL, slash `/api` endpoints) live in ./host-protocol.ts; this
* module only wires them to Playwright.
*
* Every lane consumes the same contract regardless of host version:
* Every lane consumes the same contract:
* - `PAGE_URL` / `pageUrl({...})` for page.goto (the token URL performs the
* browser's token→cookie exchange on 0.1.2-alpha.1+; a bare origin is a
* no-op on older hosts),
* browser's token→cookie exchange),
* - `sidebarApi(path)` for the plugin's own public routes,
* - `createHostApi()` for an APIRequestContext that carries the auth cookie
* when the host printed a token,
* - `hostRpc(api, 'workspace.create', {...})` for the host's unary RPC —
* dot endpoint first, slash endpoint on 404 fallback (see host-protocol).
* - `createHostApi()` for an APIRequestContext carrying the auth cookie,
* - `hostRpc(api, 'workspace.create', {...})` for the host's unary RPC.
*/
import { request, type APIRequestContext, type Page } from '@playwright/test'
import { parseLaunchUrl, pageUrlWith, rpcAttempts } from './host-protocol'
import { parseLaunchUrl, pageUrlWith, rpcAttempt } from './host-protocol'
const envUrl = process.env.DSH_E2E_URL
if (!envUrl) {
@@ -30,8 +27,8 @@ const LAUNCH = parseLaunchUrl(RAW_URL)
/** Origin for URL construction (a token URL would corrupt path joins). */
export const ORIGIN = LAUNCH.origin
/** page.goto target: the launch URL as printed (token included on
* 0.1.2-alpha.1+ — navigating it exchanges the token for the cookie). */
/** page.goto target: the launch URL as printed (token included —
* navigating it exchanges the token for the cookie). */
export const PAGE_URL = LAUNCH.pageUrl
/** page.goto target with extra query stamps merged (token preserved). */
@@ -64,14 +61,14 @@ export async function exchangeLaunchCookie(
let cookieHeader: string | undefined
/** page.goto through the host auth. A plain navigation goes to PAGE_URL (the
* token URL performs the browser's exchange on 0.1.2-alpha.1+), but a
* STAMPED navigation cannot: the exchange answers `303 → /` and silently
* DROPS every sibling query param (the mount lane caught the desktop-shell
* stamps vanishing this way), so pre-seed the browser context with the
* exchanged cookie and navigate the stamped URL directly. Playwright gives
* every test a fresh context, so the seeding is per-call and idempotent. */
* token URL performs the browser's exchange), but a STAMPED navigation
* cannot: the exchange answers `303 → /` and silently DROPS every sibling
* query param (the mount lane caught the desktop-shell stamps vanishing
* this way), so pre-seed the browser context with the exchanged cookie and
* navigate the stamped URL directly. Playwright gives every test a fresh
* context, so the seeding is per-call and idempotent. */
export async function gotoPage(page: Page, extra: Record<string, string> = {}): Promise<void> {
if (LAUNCH.token !== undefined && Object.keys(extra).length > 0) {
if (Object.keys(extra).length > 0) {
if (cookieHeader === undefined) cookieHeader = await exchangeLaunchCookie(RAW_URL)
const eq = cookieHeader.indexOf('=')
await page.context().addCookies([{
@@ -85,15 +82,14 @@ export async function gotoPage(page: Page, extra: Record<string, string> = {}):
await page.goto(pageUrl(extra), { waitUntil: 'domcontentloaded' })
}
/** Authenticated request context for host RPC seeding (cookie attached when
* the launch URL carried a one-time token; plain on older hosts). */
/** Authenticated request context for host RPC seeding (cookie attached). */
export async function createHostApi(): Promise<APIRequestContext> {
if (cookieHeader === undefined && LAUNCH.token !== undefined) {
if (cookieHeader === undefined) {
cookieHeader = await exchangeLaunchCookie(RAW_URL)
}
return request.newContext({
baseURL: ORIGIN,
extraHTTPHeaders: cookieHeader === undefined ? {} : { cookie: cookieHeader },
extraHTTPHeaders: { cookie: cookieHeader },
})
}
@@ -103,52 +99,36 @@ export interface HostRpcOk<T> {
value: T
}
/** Resolved dialect for hostRpc — cached after the first call so only the
* first RPC ever pays the 404 probe (dot-first: published hosts answer it
* directly; 0.1.2-alpha.1+ 404s the dot path and answers the slash one). */
let protocol: 'dot' | 'slash' | undefined
/** Test hook: forget the resolved dialect between unit-test cases. */
export function resetHostRpcForTests(): void {
protocol = undefined
}
let rpcCounter = 0
/** Call a host unary RPC (`'workspace.create'`, `'session.create'`, …) with
* the args object both dialects accept. Throws with the response body when
* the HTTP call or the envelope result fails — the lanes' seeding treats any
* failure as fatal, so the error text carries everything a report needs. */
/** Call a host unary RPC (`'workspace.create'`, `'session.create'`, …).
* Throws with the response body when the HTTP call or the envelope result
* fails — the lanes' seeding treats any failure as fatal, so the error text
* carries everything a report needs. */
export async function hostRpc<T = unknown>(
api: APIRequestContext,
method: string,
args: Record<string, unknown> = {},
): Promise<HostRpcOk<T>> {
const attempts = rpcAttempts(method, args)
const ordered = protocol === 'slash' ? [attempts[1]!, attempts[0]!] : attempts
const attempt = rpcAttempt(method, args)
rpcCounter += 1
const rpcId = `e2e-${method}-${rpcCounter}`
for (const attempt of ordered) {
const res = await api.post(attempt.path, {
data: { type: 'client-request', rpcId, method: attempt.method, payload: attempt.payload },
})
const bodyText = await res.text()
if (res.status() === 404 && protocol === undefined) continue // endpoint not claimed on this host → other dialect
if (!res.ok()) {
throw new Error(`hostRpc ${method} [${attempt.protocol}] HTTP ${res.status()}: ${bodyText.slice(0, 400)}`)
}
let envelope: { type?: string; result?: { ok: true; value: T } | { ok: false; error: unknown } }
try {
envelope = JSON.parse(bodyText) as typeof envelope
} catch {
throw new Error(`hostRpc ${method} [${attempt.protocol}]: non-JSON response: ${bodyText.slice(0, 400)}`)
}
const result = envelope.result
if (result === undefined || result.ok !== true) {
throw new Error(`hostRpc ${method} [${attempt.protocol}] envelope error: ${bodyText.slice(0, 400)}`)
}
protocol = attempt.protocol
return result
const res = await api.post(attempt.path, {
data: { type: 'client-request', rpcId, method: attempt.method, payload: attempt.payload },
})
const bodyText = await res.text()
if (!res.ok()) {
throw new Error(`hostRpc ${method} [${attempt.path}] HTTP ${res.status()}: ${bodyText.slice(0, 400)}`)
}
throw new Error(`hostRpc ${method}: no dialect answered (dot and slash both 404) — is this a DSH web host?`)
let envelope: { type?: string; result?: { ok: true; value: T } | { ok: false; error: unknown } }
try {
envelope = JSON.parse(bodyText) as typeof envelope
} catch {
throw new Error(`hostRpc ${method} [${attempt.path}]: non-JSON response: ${bodyText.slice(0, 400)}`)
}
const result = envelope.result
if (result === undefined || result.ok !== true) {
throw new Error(`hostRpc ${method} [${attempt.path}] envelope error: ${bodyText.slice(0, 400)}`)
}
return result
}