From 77ab91e23f2d703615af33cb7b3d30361c13939b Mon Sep 17 00:00:00 2001 From: July-X <26996625+July-X@users.noreply.github.com> Date: Thu, 19 Nov 2026 18:35:35 +0800 Subject: [PATCH] fix(webui): use the Windows folder dialog for local projects --- packages/webui/docs/client/composer.md | 12 ++ .../client/bindings/browser-capabilities.tsx | 5 + .../composer/ui/ComposerProjectRow.tsx | 99 ++++++++++-- packages/webui/src/client/main.tsx | 6 + .../platform/native-directory-picker.ts | 46 ++++++ .../webui/src/server/http/native-directory.ts | 107 +++++++++++++ packages/webui/src/server/http/router.ts | 12 ++ packages/webui/src/server/index.ts | 2 + packages/webui/src/server/service.ts | 7 + packages/webui/test/browser/composer.spec.mjs | 78 ++++++++++ .../gates/fixtures/path-metadata-f00.json | 16 +- .../test/unit/native-directory-picker.test.ts | 147 ++++++++++++++++++ .../webui/test/unit/webui-service.test.ts | 19 +++ release/public-source.json | 5 + release/webui-npm/bin/mcode-webui.mjs | 28 +++- .../webui-npm/bin/native-directory-picker.mjs | 106 +++++++++++++ .../webui-npm/bin/native-directory-picker.ps1 | 64 ++++++++ test/source-sync.test.mjs | 109 +++++++++++++ test/vitest-suites.json | 1 + 19 files changed, 847 insertions(+), 22 deletions(-) create mode 100644 packages/webui/src/client/platform/native-directory-picker.ts create mode 100644 packages/webui/src/server/http/native-directory.ts create mode 100644 packages/webui/test/unit/native-directory-picker.test.ts create mode 100644 release/webui-npm/bin/native-directory-picker.mjs create mode 100644 release/webui-npm/bin/native-directory-picker.ps1 diff --git a/packages/webui/docs/client/composer.md b/packages/webui/docs/client/composer.md index 74767cc65..692da66db 100644 --- a/packages/webui/docs/client/composer.md +++ b/packages/webui/docs/client/composer.md @@ -33,6 +33,18 @@ text preserves the target draft. Synchronous subscribers can edit the committed later transfer write replacing their changes. Conflicts publish nothing and keep the retained source; the notice shows a transfer error beside its action so the user can select another destination and retry. +## Workspace folder selection + +For a locally launched Windows WebUI with a native directory-picker grant, opening +`选择新项目` offers `选择此电脑上的文件夹` and `添加文件夹`. The add action opens the +native Windows directory chooser; confirming a folder changes the next session's work +directory. Cancelling the system chooser, dismissing the WebUI dialog or failing to +open the chooser does not change the current workspace. + +Remote browsers and launches without the local grant use the existing server +directory browser instead. Its paths refer to the machine running WebUI, not +to the browser's device. The native entry also offers this fallback explicitly. + ## Where the pieces live - The surface is `client/features/composer/ui/WebuiComposer.tsx`, with the editor staging, menus, diff --git a/packages/webui/src/client/bindings/browser-capabilities.tsx b/packages/webui/src/client/bindings/browser-capabilities.tsx index 889dea434..06b52a040 100644 --- a/packages/webui/src/client/bindings/browser-capabilities.tsx +++ b/packages/webui/src/client/bindings/browser-capabilities.tsx @@ -1,10 +1,15 @@ import { createContext, useContext, type ReactNode } from "react"; import { EMPTY_WEBUI_BROWSER_DOM, type WebuiBrowserDom } from "../platform/browser-dom.js"; +import type { NativeWorkspaceDirectoryResult } from "../platform/native-directory-picker.js"; import { createWebuiBrowserStorage, type WebuiBrowserStorage } from "../platform/storage.js"; export interface WebuiBrowserCapabilities { readonly dom: WebuiBrowserDom; readonly storage: WebuiBrowserStorage; + readonly nativeDirectoryPicker?: { + readonly available: () => boolean; + readonly choose: (signal: AbortSignal) => Promise; + }; /** * The runtime's data directory, when the host served the page with one. * diff --git a/packages/webui/src/client/features/composer/ui/ComposerProjectRow.tsx b/packages/webui/src/client/features/composer/ui/ComposerProjectRow.tsx index ce9996484..625d6df29 100644 --- a/packages/webui/src/client/features/composer/ui/ComposerProjectRow.tsx +++ b/packages/webui/src/client/features/composer/ui/ComposerProjectRow.tsx @@ -15,11 +15,12 @@ // a layer of its own, so the coordinator dismisses it and it keeps no listener. // The menu's open state stays a prop because the shell owns it. -import { useState } from "react"; +import { useEffect, useRef, useState } from "react"; import { WebuiDropdown } from "../../../ui/Dropdown.js"; import { WebuiButton } from "../../../ui/button.js"; import { WebuiDialog } from "../../../ui/dialog.js"; +import { useWebuiToastError } from "../../../ui/toast.js"; import { useWebuiBrowserCapabilities } from "../../../bindings/browser-capabilities.js"; import { workspaceProjectName } from "../../../features/workspace/projection/workspace-name.public.js"; import { WebuiWorkspaceDirectoryBrowser } from "../../../features/workspace/ui/WebuiWorkspaceDirectoryBrowser.public.js"; @@ -44,8 +45,63 @@ export function WebuiComposerProjectRow({ onMenuOpenChange, onSelectProject, }: WebuiComposerProjectRowProps) { + const { dom, nativeDirectoryPicker } = useWebuiBrowserCapabilities(); const [browserOpen, setBrowserOpen] = useState(false); - const { dom } = useWebuiBrowserCapabilities(); + const [nativeMode, setNativeMode] = useState(false); + const [nativePending, setNativePending] = useState(false); + const [nativeError, setNativeError] = useState(""); + useWebuiToastError(nativeError); + const request = useRef(null); + const nativeAddButton = useRef(null); + useEffect(() => () => { + request.current?.abort(); + request.current = null; + }, []); + + function closeBrowser() { + request.current?.abort(); + request.current = null; + setNativePending(false); + setNativeError(""); + setBrowserOpen(false); + } + + function showServerBrowser() { + request.current?.abort(); + request.current = null; + setNativePending(false); + setNativeError(""); + setNativeMode(false); + } + + async function addFolder() { + if (!nativeDirectoryPicker || request.current) return; + const current = new AbortController(); + request.current = current; + setNativePending(true); + setNativeError(""); + try { + const result = await nativeDirectoryPicker.choose(current.signal); + if (request.current !== current) return; + if (result.kind === "selected") { + closeBrowser(); + onSelectProject(result.directory); + } else if (result.kind === "unavailable") { + showServerBrowser(); + } + } catch (error) { + if (request.current === current) { + setNativeError(error instanceof Error && !(error instanceof TypeError) + ? error.message + : "无法打开系统目录选择,请重试或选择服务端目录。"); + } + } finally { + if (request.current === current) { + request.current = null; + setNativePending(false); + } + } + } return (
@@ -125,6 +181,7 @@ export function WebuiComposerProjectRow({ className="webui-workspace-option" onClick={() => { onMenuOpenChange(false); + setNativeMode(nativeDirectoryPicker?.available() ?? false); setBrowserOpen(true); }} > @@ -150,25 +207,41 @@ export function WebuiComposerProjectRow({ setBrowserOpen(false)} + initialFocusRef={nativeMode ? nativeAddButton : undefined} + onClose={closeBrowser} dismissOnEscape dismissOnBackdrop testId="webui-workspace-browser-dialog" dataAttributes={{ "data-webui-workspace-browser-dialog": "true" }} bodyClassName="webui-workspace-browser-dialog-body" > - { - setBrowserOpen(false); - onSelectProject(dir); - }} - onCancel={() => setBrowserOpen(false)} - /> + {nativeMode ? ( +
+
+ void addFolder()}> + {nativePending ? "正在等待系统选择窗口…" : "+ 添加文件夹"} + + + 浏览服务端目录 + +
+
+ ) : ( + { + closeBrowser(); + onSelectProject(dir); + }} + onCancel={closeBrowser} + /> + )}
diff --git a/packages/webui/src/client/main.tsx b/packages/webui/src/client/main.tsx index 631d202ce..f366395b2 100644 --- a/packages/webui/src/client/main.tsx +++ b/packages/webui/src/client/main.tsx @@ -20,6 +20,7 @@ import { ArchonPage } from "./shell/ArchonPage.js"; import { WebuiErrorBoundary } from "./shell/WebuiErrorBoundary.js"; import { WebuiStartupFallback } from "./shell/StartupFallback.js"; import { WebuiBrowserCapabilitiesProvider } from "./bindings/browser-capabilities.js"; +import { canPickNativeWorkspaceDirectory, captureNativeDirectoryLaunchGrant, pickNativeWorkspaceDirectory } from "./platform/native-directory-picker.js"; import { createWebuiBrowserDom } from "./platform/browser-dom.js"; import { MiniAppStandalone } from "./features/miniapp/ui/MiniAppStandalone.public.js"; import { WebuiMiniAppWorkflowsProvider } from "./features/miniapp/bindings/use-miniapp-workflows.js"; @@ -137,6 +138,7 @@ function installWebuiStallDiagnostics(): void { }, 1_000); } +captureNativeDirectoryLaunchGrant(); installWebuiStallDiagnostics(); const rootElement = document.getElementById("webui-root"); @@ -324,6 +326,10 @@ const root: Root = createRoot(rootElement); const browserCapabilities = { dom: createWebuiBrowserDom(globalThis.document, globalThis.window), storage: createWebuiBrowserStorage(getWebuiBrowserStorage()), + nativeDirectoryPicker: { + available: canPickNativeWorkspaceDirectory, + choose: pickNativeWorkspaceDirectory, + }, // The runtime's data directory is a fact about this host: the composition // root is the one place that may read the injected config, and the surfaces // that need it read it from the capabilities. diff --git a/packages/webui/src/client/platform/native-directory-picker.ts b/packages/webui/src/client/platform/native-directory-picker.ts new file mode 100644 index 000000000..480809a81 --- /dev/null +++ b/packages/webui/src/client/platform/native-directory-picker.ts @@ -0,0 +1,46 @@ +// Ephemeral desktop grant: only the local launcher gives it to its auto-opened +// page. Never persist it, expose it in runtime config, or send it cross-origin. +import { readWebuiSessionTransferTarget } from "./session-transfer-target.js"; + +export type NativeWorkspaceDirectoryResult = + | { readonly kind: "selected"; readonly directory: string } + | { readonly kind: "cancelled" } + | { readonly kind: "unavailable" }; +let launch: { readonly origin: string; readonly grant: string } | undefined; + +export function captureNativeDirectoryLaunchGrant(): void { + launch = undefined; + const url = new URL(globalThis.location.href); + const fragment = new URLSearchParams(url.hash.slice(1)); + const grant = fragment.get("nativeDirectoryGrant"); + if (grant === null) return; + fragment.delete("nativeDirectoryGrant"); + url.hash = fragment.toString(); + // Remove even an invalid grant before any app routing or other interactions. + globalThis.history.replaceState(globalThis.history.state, "", url.href); + if (url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "[::1]") && + /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/iu.test(grant)) { + launch = { origin: url.origin, grant }; + } +} +export function canPickNativeWorkspaceDirectory(): boolean { + const target = readWebuiSessionTransferTarget(); + return Boolean(launch && target?.origin === launch.origin && target.token); +} +export async function pickNativeWorkspaceDirectory(signal: AbortSignal): Promise { + const target = readWebuiSessionTransferTarget(); + if (!launch || !target?.token || target.origin !== launch.origin) return { kind: "unavailable" }; + const response = await globalThis.fetch(`${launch.origin}/native-directory-picker`, { + method: "POST", credentials: "same-origin", signal, + headers: { "X-Webui-Native-Grant": launch.grant, "X-Webui-Token": target.token }, + }); + if ([401, 403, 404].includes(response.status)) { launch = undefined; return { kind: "unavailable" }; } + if (!response.ok) throw new Error(response.status === 409 ? "已有系统目录选择窗口,请先完成或取消。" : "系统目录选择失败,请重试或选择服务端目录。"); + const result: unknown = await response.json(); + if (result && typeof result === "object" && "kind" in result) { + if (result.kind === "cancelled") return { kind: "cancelled" }; + if (result.kind === "selected" && "directory" in result && typeof result.directory === "string" && result.directory.length > 0) + return { kind: "selected", directory: result.directory }; + } + throw new Error("系统目录选择返回了无效结果。"); +} diff --git a/packages/webui/src/server/http/native-directory.ts b/packages/webui/src/server/http/native-directory.ts new file mode 100644 index 000000000..3fe8f37e5 --- /dev/null +++ b/packages/webui/src/server/http/native-directory.ts @@ -0,0 +1,107 @@ +// Desktop capability supplied only by an interactive local launcher. General +// WebUI credentials alone never authorize opening native desktop UI. +import type { IncomingMessage, ServerResponse } from "node:http"; +import { timingSafeEqual } from "node:crypto"; +import { credentialPresented, type WebuiCredential } from "../credentials.js"; +import { stat } from "node:fs/promises"; +import { isAbsolute } from "node:path"; +import { rejectHttp } from "./responses.js"; + +export interface WebuiNativeDirectoryPicker { + readonly grant: string; + /** Abort must close the owned dialog and settle after its process exits. */ + choose(signal: AbortSignal): Promise<{ readonly kind: "selected"; readonly directory: string } | { readonly kind: "cancelled" }>; + dispose(): Promise; +} +interface Admission { + readonly host: string; + readonly port?: number; + readonly fullAccess?: boolean; + readonly credential: WebuiCredential; +} +const loopback = (value: string | undefined) => value === "127.0.0.1" || value === "::1" || value === "::ffff:127.0.0.1"; +function equalSecret(value: string | string[] | undefined, expected: string): boolean { + if (typeof value !== "string" || !expected) return false; + const a = Buffer.from(value); const b = Buffer.from(expected); + return a.length === b.length && timingSafeEqual(a, b); +} +/** Same absolute/existing-directory semantics as the operation validator, + * but never block the HTTP event loop on a disconnected Windows share. The OS + * stat itself is not cancellable; its late result is ignored after the bound. */ +export async function validateNativeDirectory( + directory: string, + timeoutMs = 3_000, + inspect: (path: string) => Promise<{ isDirectory(): boolean }> = stat, +): Promise { + if (typeof directory !== "string" || !isAbsolute(directory)) return false; + let timer: ReturnType | undefined; + try { + return await Promise.race([ + Promise.resolve().then(() => inspect(directory)).then(value => value.isDirectory(), () => false), + new Promise(resolve => { timer = setTimeout(() => resolve(false), timeoutMs); }), + ]); + } finally { clearTimeout(timer); } +} +export function createNativeDirectoryRoute(picker: WebuiNativeDirectoryPicker, timeoutMs = 120_000) { + let active: { controller: AbortController; settled: Promise } | undefined; + let closed = false; + return { + async handle(request: IncomingMessage, response: ServerResponse, context: Admission): Promise { + response.setHeader("Cache-Control", "no-store"); + const authority = context.host === "::1" ? `[::1]:${context.port}` : `${context.host}:${context.port}`; + if (closed || context.fullAccess || !loopback(context.host) || !loopback(request.socket.remoteAddress) || + !context.port || request.headers.host !== authority || request.headers.origin !== `http://${authority}` || + request.headers["sec-fetch-site"] !== "same-origin" || + Object.keys(request.headers).some((key) => key === "forwarded" || key.startsWith("x-forwarded-")) || + !equalSecret(request.headers["x-webui-native-grant"], picker.grant)) { + rejectHttp(response, 403, "Native directory selection unavailable"); return; + } + if (!credentialPresented(context.credential, + typeof request.headers["x-webui-token"] === "string" ? request.headers["x-webui-token"] : undefined, + request.headers.cookie)) { + rejectHttp(response, 401, "Unauthorized"); return; + } + // This command takes no client path, command or options. Empty POST only. + if ((request.headers["content-length"] !== undefined && request.headers["content-length"] !== "0") || + request.headers["transfer-encoding"] !== undefined) { + rejectHttp(response, 400, "Native directory selection accepts no body"); return; + } + if (active) { rejectHttp(response, 409, "A directory chooser is already open"); return; } + const controller = new AbortController(); + const abort = () => { if (!response.writableEnded) controller.abort(); }; + request.once("aborted", abort); response.once("close", abort); + const timer = setTimeout(() => controller.abort(), timeoutMs); + // Defer choose so the singleton exists even if a provider throws synchronously. + const settled = Promise.resolve().then(() => picker.choose(controller.signal)); + active = { controller, settled }; + try { + const result = await settled; + if (response.destroyed) return; + if (controller.signal.aborted || result.kind === "cancelled") { + response.setHeader("Content-Type", "application/json"); response.end(JSON.stringify({ kind: "cancelled" })); return; + } + const valid = await validateNativeDirectory(result.directory); + if (response.destroyed) return; + if (controller.signal.aborted) { + response.setHeader("Content-Type", "application/json"); response.end(JSON.stringify({ kind: "cancelled" })); return; + } + if (!valid) { rejectHttp(response, 422, "The selected directory is no longer available"); return; } + response.setHeader("Content-Type", "application/json"); + response.end(JSON.stringify({ kind: "selected", directory: result.directory })); + } catch { + if (!response.destroyed) { + // An abort request is not proof that the native window closed. Only + // the provider's settled cancellation result establishes that. + rejectHttp(response, 503, "Native directory selection failed"); + } + } finally { + clearTimeout(timer); request.off("aborted", abort); response.off("close", abort); active = undefined; + } + }, + async dispose(): Promise { + closed = true; active?.controller.abort(); + await picker.dispose(); + await active?.settled.catch(() => undefined); + }, + }; +} diff --git a/packages/webui/src/server/http/router.ts b/packages/webui/src/server/http/router.ts index 260dd80f8..ff18b1056 100644 --- a/packages/webui/src/server/http/router.ts +++ b/packages/webui/src/server/http/router.ts @@ -1,3 +1,4 @@ +import type { createNativeDirectoryRoute } from "./native-directory.js"; // HTTP router for the loopback service: dispatch one admitted request to the // session-transfer, workspace-file or static client-asset route. Split from // `service.ts` with no behaviour change — the admission order, route order, @@ -26,6 +27,7 @@ import type { WebuiBrowserExtensionPackage } from "../browser-bridge/extension-p export interface WebuiHttpRouterContext { readonly host: string; + readonly nativeDirectoryRoute?: ReturnType; /** The TCP port the kernel allocated, once `start()` has resolved. */ readonly boundTcpPort: () => number | undefined; /** The configured TCP port, used as the client-asset fallback before bind. */ @@ -97,6 +99,16 @@ export async function serveHttpRequest( await serveDesignAsset(request, response, url, context.port); return; } + if (url.pathname === "/native-directory-picker") { + if (request.method !== "POST" || url.search || !context.nativeDirectoryRoute) { + rejectHttp(response, 404, "Not Found"); return; + } + await context.nativeDirectoryRoute.handle(request, response, { + host: context.host, port: context.boundTcpPort(), credential: context.credential, + fullAccess: context.fullAccess, + }); + return; + } if (request.method === "GET" && url.pathname === "/session-transfer") { await handleSessionTransfer(url, response, context.port); return; diff --git a/packages/webui/src/server/index.ts b/packages/webui/src/server/index.ts index 9ee152b7a..953424533 100644 --- a/packages/webui/src/server/index.ts +++ b/packages/webui/src/server/index.ts @@ -130,3 +130,5 @@ export type { WebuiPermissionDecision, } from "../shared/contracts/interactions.js"; export type { WebuiModelEntry } from "../shared/contracts/models.js"; + +export type { WebuiNativeDirectoryPicker } from "./http/native-directory.js"; diff --git a/packages/webui/src/server/service.ts b/packages/webui/src/server/service.ts index 0b2a9d016..d1cf511dc 100644 --- a/packages/webui/src/server/service.ts +++ b/packages/webui/src/server/service.ts @@ -18,6 +18,8 @@ // Shutdown order is the close order `../docs/runtime/boot.md` states: stop accepting // new operations, then close every connection, then close the harness. +import { createNativeDirectoryRoute, type WebuiNativeDirectoryPicker } from "./http/native-directory.js"; + import type { IncomingMessage, Server, ServerResponse } from "node:http"; import type { WebuiOperationRegistryEntry } from "./operation/operations.js"; @@ -152,6 +154,7 @@ export interface WebuiServiceOptions { * it. Absent when the host has none. */ readonly requestShutdown?: () => void; + readonly nativeDirectoryPicker?: WebuiNativeDirectoryPicker; /** Optional server factory; tests inject an HTTP server without listening. */ readonly httpServerFactory?: () => Server; /** @@ -279,6 +282,7 @@ export class WebuiService { ...(this.browserBridge ? { browserBridge: this.browserBridge } : {}), }); this.httpContext = { + ...(options.nativeDirectoryPicker ? { nativeDirectoryRoute: createNativeDirectoryRoute(options.nativeDirectoryPicker) } : {}), host: this.host, boundTcpPort: () => this.bound?.info.tcpPort, configuredTcpPort: this.tcpPort, @@ -367,6 +371,9 @@ export class WebuiService { }; this.accepting = false; + if (this.httpContext.nativeDirectoryRoute) { + await attempt("native-directory-picker", () => this.httpContext.nativeDirectoryRoute!.dispose()); + } await attempt("terminal", () => this.terminal?.disposeBySession()); // Terminate sockets before waiting for their listener to close. await attempt("websocket-connections", () => this.wsServer.closeConnections()); diff --git a/packages/webui/test/browser/composer.spec.mjs b/packages/webui/test/browser/composer.spec.mjs index 1a9849244..8fc37b8f4 100644 --- a/packages/webui/test/browser/composer.spec.mjs +++ b/packages/webui/test/browser/composer.spec.mjs @@ -519,6 +519,84 @@ test("the workspace picker opens above its row, inside the viewport", async ({ p expect(box.bottom).toBeLessThanOrEqual(box.height); }); +test("native workspace picker preserves selection on cancel and accepts a drive path", async ({ page }) => { + const grant = "12345678-1234-1234-1234-123456789abc"; + const folder = "E:\\Games\\OtherProject"; + let calls = 0; + await page.route("**/native-directory-picker", async (route) => { + expect(route.request().method()).toBe("POST"); + expect(route.request().headers()["x-webui-native-grant"]).toBe(grant); + expect(route.request().headers()["x-webui-token"]).toBe("synthetic-token"); + calls += 1; + await route.fulfill({ json: calls === 1 + ? { kind: "cancelled" } + : { kind: "selected", directory: folder } }); + }); + await openApp(page, `#nativeDirectoryGrant=${grant}`); + expect(new URL(page.url()).hash).not.toContain(grant); + const row = page.locator('[data-webui-workspace-picker="true"]').first(); + const previous = await row.innerText(); + await row.click(); + await page.getByRole("option", { name: "选择新项目" }).click(); + const dialog = page.getByRole("dialog", { name: "选择新项目" }); + await expect(dialog.getByText("选择此电脑上的文件夹")).toBeVisible(); + const add = dialog.getByRole("button", { name: "添加文件夹" }); + await add.click(); + await expect.poll(() => calls).toBe(1); + await expect(add).toBeEnabled(); + await expect(row).toHaveText(previous); + await add.click(); + await expect(dialog).toBeHidden(); + await expect(row).toHaveText("OtherProject"); +}); + +test("dismissing the WebUI dialog aborts the pending native workspace picker", async ({ page }) => { + const grant = "12345678-1234-1234-1234-123456789abc"; + await configureFixture(page, () => { + const fetch = window.fetch.bind(window); + window.fetch = (url, options) => { + if (!String(url).endsWith("/native-directory-picker")) return fetch(url, options); + window.__nativeDirectoryRequest = { aborted: false }; + options.signal.addEventListener("abort", () => { + window.__nativeDirectoryRequest.aborted = true; + }); + return new Promise((resolve) => { + window.__completeNativeDirectoryRequest = () => resolve(new Response(JSON.stringify({ + kind: "selected", directory: "E:/VanishedProject", + }))); + }); + }; + }); + await openApp(page, `#nativeDirectoryGrant=${grant}`); + const row = page.locator('[data-webui-workspace-picker="true"]').first(); + const previous = await row.innerText(); + await row.click(); + await page.getByRole("option", { name: "选择新项目" }).click(); + const dialog = page.getByRole("dialog", { name: "选择新项目" }); + await dialog.getByRole("button", { name: "添加文件夹" }).click(); + await expect(dialog.getByRole("button", { name: "正在等待系统选择窗口" })).toBeDisabled(); + await page.keyboard.press("Escape"); + await expect(dialog).toBeHidden(); + expect(await page.evaluate(() => window.__nativeDirectoryRequest.aborted)).toBe(true); + await page.evaluate(() => window.__completeNativeDirectoryRequest()); + await expect(row).toHaveText(previous); +}); + +test("ordinary WebUI clients use the server directory browser", async ({ page }) => { + let nativeCalls = 0; + await page.route("**/native-directory-picker", async (route) => { + nativeCalls += 1; + await route.abort(); + }); + await openApp(page, "#"); + await page.locator('[data-webui-workspace-picker="true"]').first().click(); + await page.getByRole("option", { name: "选择新项目" }).click(); + const dialog = page.getByRole("dialog", { name: "选择项目目录" }); + await expect(dialog.getByText("选择运行 WebUI 的主机上用于新会话的工作目录")).toBeVisible(); + await expect(dialog.getByRole("button", { name: "添加文件夹" })).toHaveCount(0); + expect(nativeCalls).toBe(0); +}); + test("↑ recalls committed inputs; a manual edit exits the browse", async ({ page }) => { await openApp(page, "#session=A"); diff --git a/packages/webui/test/gates/fixtures/path-metadata-f00.json b/packages/webui/test/gates/fixtures/path-metadata-f00.json index d1231eb38..2efc3376b 100644 --- a/packages/webui/test/gates/fixtures/path-metadata-f00.json +++ b/packages/webui/test/gates/fixtures/path-metadata-f00.json @@ -2,7 +2,7 @@ "baseline": "f00b1268c28ad15054a8882620c3fb08beb86d58", "sourceSha256": "46b86b658adc1611f3531d8dc9844612f7e9ee3de0eec4a532aeec44b5de0a12", "nativeDesignDelta": "Adds the native Design feature across its existing application, binding, contract, projection and UI roles, with runtime-owned storage and execution, server adapters, and shared DTOs. Layer rules, role rules and the frozen direction matrix are unchanged.", - "declaredDelta": "Public marker preserves the original layer and adds only the published- role prefix; publication legality has separate positive/negative fixtures. Post-baseline additions: conversation/pagination remains a mechanism, platform/transport-origin remains infrastructure, runtime/ssh/authentication remains outside the client, bindings/use-webui-shutdown remains a binding, platform/webui-shutdown remains infrastructure, server/http/shutdown remains outside the client, and client/styles/brand-font remains a stylesheet.", + "declaredDelta": "Public marker preserves the original layer and adds only the published- role prefix; publication legality has separate positive/negative fixtures. Post-baseline additions: platform/native-directory-picker remains infrastructure, server/http/native-directory remains outside the client, conversation/pagination remains a mechanism, platform/transport-origin remains infrastructure, runtime/ssh/authentication remains outside the client, bindings/use-webui-shutdown remains a binding, platform/webui-shutdown remains infrastructure, server/http/shutdown remains outside the client, and client/styles/brand-font remains a stylesheet.", "cases": [ { "path": "client/features/design/application/design-owner.ts", "layers": ["application"], "role": "feature-application", "business": "design", "home": "target" }, { "path": "client/features/design/bindings/use-design.ts", "layers": ["bindings"], "role": "feature-bindings", "business": "design", "home": "target" }, @@ -25,6 +25,20 @@ { "path": "server/operation/design.ts", "layers": ["server"], "role": "outside", "business": null, "home": "outside" }, { "path": "shared/contracts/design.ts", "layers": ["shared"], "role": "outside", "business": null, "home": "outside" }, { "path": "shared/design-input.ts", "layers": ["shared"], "role": "outside", "business": null, "home": "outside" }, + { + "path": "client/platform/native-directory-picker.ts", + "layers": ["infrastructure"], + "role": "platform", + "business": null, + "home": "target" + }, + { + "path": "server/http/native-directory.ts", + "layers": ["server"], + "role": "outside", + "business": null, + "home": "outside" + }, { "path": "runtime/native-pty.ts", "layers": ["runtime"], diff --git a/packages/webui/test/unit/native-directory-picker.test.ts b/packages/webui/test/unit/native-directory-picker.test.ts new file mode 100644 index 000000000..f58a20a13 --- /dev/null +++ b/packages/webui/test/unit/native-directory-picker.test.ts @@ -0,0 +1,147 @@ +import { EventEmitter } from "node:events"; +import { tmpdir } from "node:os"; +import { createServer, type IncomingMessage, type ServerResponse } from "node:http"; +import { once } from "node:events"; +import { afterEach, describe, expect, it, vi } from "vitest"; +import { createNativeDirectoryRoute, validateNativeDirectory } from "../../src/server/http/native-directory.js"; +import { captureNativeDirectoryLaunchGrant, canPickNativeWorkspaceDirectory, pickNativeWorkspaceDirectory } from "../../src/client/platform/native-directory-picker.js"; + +const grant = "11111111-2222-3333-4444-555555555555"; +const context = { host: "127.0.0.1", port: 2233, credential: { token: "test-token" }, fullAccess: false }; +function request(headers: Record = {}, address = "127.0.0.1") { + return Object.assign(new EventEmitter(), { headers: { + host: "127.0.0.1:2233", origin: "http://127.0.0.1:2233", "sec-fetch-site": "same-origin", + "x-webui-native-grant": grant, "x-webui-token": "test-token", ...headers, + }, socket: { remoteAddress: address } }) as unknown as IncomingMessage; +} +function response() { + const value = Object.assign(new EventEmitter(), { + statusCode: 200, body: "", destroyed: false, writableEnded: false, + setHeader: vi.fn(), writeHead(status: number) { this.statusCode = status; }, end(body: string) { this.body = body; this.writableEnded = true; }, + }); + return value; +} +const asResponse = (value: ReturnType) => value as unknown as ServerResponse; +afterEach(() => { vi.unstubAllGlobals(); vi.restoreAllMocks(); }); + +describe("native directory HTTP desktop capability", () => { + it("bounds returned-directory inspection without blocking on an unavailable share", async () => { + const inspect = vi.fn(() => new Promise<{ isDirectory(): boolean }>(() => {})); + expect(await validateNativeDirectory(tmpdir(), 5, inspect)).toBe(false); + expect(inspect).toHaveBeenCalledTimes(1); + expect(await validateNativeDirectory("relative", 5, inspect)).toBe(false); + expect(inspect).toHaveBeenCalledTimes(1); + expect(await validateNativeDirectory(tmpdir(), 5, async () => ({ isDirectory: () => false }))).toBe(false); + }); + it("serves a real authenticated loopback POST without query credentials", async () => { + const choose = vi.fn(async () => ({ kind: "selected" as const, directory: tmpdir() })); + const route = createNativeDirectoryRoute({ grant, choose, dispose: async () => {} }); + const server = createServer((req, res) => { + const address = server.address(); + void route.handle(req, res, { ...context, port: typeof address === "object" && address ? address.port : 0 }); + }); + server.listen(0, "127.0.0.1"); await once(server, "listening"); + const address = server.address(); if (!address || typeof address === "string") throw new Error("Missing TCP address"); + const origin = `http://127.0.0.1:${address.port}`; + try { + const response = await fetch(`${origin}/native-directory-picker`, { method: "POST", headers: { + Origin: origin, "Sec-Fetch-Site": "same-origin", "X-Webui-Native-Grant": grant, "X-Webui-Token": "test-token", + } }); + expect(response.status).toBe(200); expect(await response.json()).toEqual({ kind: "selected", directory: tmpdir() }); + expect(choose).toHaveBeenCalledTimes(1); + } finally { + await route.dispose(); server.closeAllConnections(); await new Promise(resolve => server.close(() => resolve())); + } + }); + it.each>([ + { origin: "" }, { origin: "null" }, { origin: "http://evil.example:2233" }, + { origin: "https://127.0.0.1:2233" }, { host: "localhost:2233" }, + { "sec-fetch-site": "cross-site" }, { forwarded: "for=127.0.0.1" }, + { "x-forwarded-host": "example.test" }, { "x-webui-native-grant": "wrong" }, + ])("denies unsafe request %j without invoking provider", async (headers) => { + const choose = vi.fn(); const route = createNativeDirectoryRoute({ grant, choose, dispose: async () => {} }); + const res = response(); await route.handle(request(headers), asResponse(res), context); + expect(res.statusCode).toBe(403); expect(choose).not.toHaveBeenCalled(); + }); + it.each([{ ...context, fullAccess: true }, { ...context, host: "0.0.0.0" }])("denies deployment %j", async (admission) => { + const choose = vi.fn(); const res = response(); + await createNativeDirectoryRoute({ grant, choose, dispose: async () => {} }).handle(request(), asResponse(res), admission); + expect(res.statusCode).toBe(403); expect(choose).not.toHaveBeenCalled(); + }); + it("requires credential even in a locally admitted service and refuses remote sockets", async () => { + const choose = vi.fn(); const route = createNativeDirectoryRoute({ grant, choose, dispose: async () => {} }); + const missing = response(); await route.handle(request({ "x-webui-token": "" }), asResponse(missing), context); + expect(missing.statusCode).toBe(401); + const remote = response(); await route.handle(request({}, "192.0.2.1"), asResponse(remote), context); + expect(remote.statusCode).toBe(403); expect(choose).not.toHaveBeenCalled(); + }); + it("accepts no request body or client-selected path", async () => { + const choose = vi.fn(); const res = response(); + await createNativeDirectoryRoute({ grant, choose, dispose: async () => {} }).handle(request({ "content-length": "10" }), asResponse(res), context); + expect(res.statusCode).toBe(400); expect(choose).not.toHaveBeenCalled(); + }); + it.each([ + [{ kind: "selected", directory: tmpdir() }, 200], + [{ kind: "selected", directory: "relative-directory" }, 422], + [{ kind: "cancelled" }, 200], + ] as const)("validates native result %j", async (result, status) => { + const res = response(); + await createNativeDirectoryRoute({ grant, choose: async () => result, dispose: async () => {} }).handle(request(), asResponse(res), context); + expect(res.statusCode).toBe(status); + if (status === 200) expect(JSON.parse(res.body)).toEqual(result); + }); + it("holds one dialog, aborts on disconnect, and permits another after settlement", async () => { + let signal!: AbortSignal; + const choose = vi.fn((value: AbortSignal) => { signal = value; return new Promise<{ kind: "cancelled" }>(resolve => value.addEventListener("abort", () => resolve({ kind: "cancelled" }))); }); + const route = createNativeDirectoryRoute({ grant, choose, dispose: async () => {} }); + const first = response(); const pending = route.handle(request(), asResponse(first), context); + await Promise.resolve(); + const second = response(); await route.handle(request(), asResponse(second), context); + expect(second.statusCode).toBe(409); expect(choose).toHaveBeenCalledTimes(1); + first.destroyed = true; first.emit("close"); await pending; expect(signal.aborted).toBe(true); + const third = response(); const again = route.handle(request(), asResponse(third), context); + await Promise.resolve(); await route.dispose(); await again; + expect(choose).toHaveBeenCalledTimes(2); expect(signal.aborted).toBe(true); + }); + it("times out by cancelling the owned provider and sanitizes provider failures", async () => { + const res = response(); + const route = createNativeDirectoryRoute({ grant, choose: signal => new Promise(resolve => signal.addEventListener("abort", () => resolve({ kind: "cancelled" }))), dispose: async () => {} }, 5); + await route.handle(request(), asResponse(res), context); expect(JSON.parse(res.body)).toEqual({ kind: "cancelled" }); + const failure = response(); + await createNativeDirectoryRoute({ grant, choose: async () => { throw new Error("private details"); }, dispose: async () => {} }).handle(request(), asResponse(failure), context); + expect(failure.statusCode).toBe(503); expect(failure.body).not.toContain("private"); + }); +}); + +function browser(url = `http://127.0.0.1:2233/#nativeDirectoryGrant=${grant}&session=A`) { + vi.stubGlobal("location", new URL(url)); + const replaceState = vi.fn(); vi.stubGlobal("history", { state: null, replaceState }); + vi.stubGlobal("__WEBUI_CONFIG__", { websocketUrl: "ws://127.0.0.1:2233", token: "test-token" }); + captureNativeDirectoryLaunchGrant(); return replaceState; +} +describe("native directory launch grant transport", () => { + it("strips fragment immediately, preserves session, and sends secrets only in same-origin headers", async () => { + const replace = browser(); expect(replace.mock.calls[0]?.[2]).toBe("http://127.0.0.1:2233/#session=A"); + expect(canPickNativeWorkspaceDirectory()).toBe(true); + const fetch = vi.fn(async () => new Response(JSON.stringify({ kind: "selected", directory: "C:\\Work" }))); + vi.stubGlobal("fetch", fetch); const signal = new AbortController().signal; + expect(await pickNativeWorkspaceDirectory(signal)).toEqual({ kind: "selected", directory: "C:\\Work" }); + expect(fetch).toHaveBeenCalledWith("http://127.0.0.1:2233/native-directory-picker", { + method: "POST", credentials: "same-origin", signal, headers: { "X-Webui-Native-Grant": grant, "X-Webui-Token": "test-token" }, + }); + }); + it("does not grant a refreshed, remote or mismatched-runtime page native access", async () => { + for (const url of ["http://127.0.0.1:2233/", `http://example.test/#nativeDirectoryGrant=${grant}`]) { + browser(url); expect(canPickNativeWorkspaceDirectory()).toBe(false); + } + browser(); vi.stubGlobal("__WEBUI_CONFIG__", { websocketUrl: "ws://127.0.0.1:9999", token: "test-token" }); + expect(await pickNativeWorkspaceDirectory(new AbortController().signal)).toEqual({ kind: "unavailable" }); + }); + it("reports cancel and revokes unsupported grants instead of selecting a path", async () => { + browser(); vi.stubGlobal("fetch", vi.fn(async () => new Response(JSON.stringify({ kind: "cancelled" })))); + expect(await pickNativeWorkspaceDirectory(new AbortController().signal)).toEqual({ kind: "cancelled" }); + vi.stubGlobal("fetch", vi.fn(async () => new Response("", { status: 403 }))); + expect(await pickNativeWorkspaceDirectory(new AbortController().signal)).toEqual({ kind: "unavailable" }); + expect(canPickNativeWorkspaceDirectory()).toBe(false); + }); +}); diff --git a/packages/webui/test/unit/webui-service.test.ts b/packages/webui/test/unit/webui-service.test.ts index 12535e636..315b89066 100644 --- a/packages/webui/test/unit/webui-service.test.ts +++ b/packages/webui/test/unit/webui-service.test.ts @@ -1149,6 +1149,25 @@ describe("WebUI service", () => { }; } + it("routes native desktop selection only with both launch grant and credential, including dev mode", async () => { + const grant = "11111111-2222-3333-4444-555555555555"; + const choose = vi.fn(async () => ({ kind: "selected" as const, directory: os.tmpdir() })); + const dispose = vi.fn(async () => {}); + service = new WebuiService({ port, operations: createOperationRegistry(port), dev: true, + nativeDirectoryPicker: { grant, choose, dispose } }); + const info = await service.start(); + const origin = `http://127.0.0.1:${info.tcpPort}`; + const headers = { Origin: origin, "Sec-Fetch-Site": "same-origin", "X-Webui-Native-Grant": grant }; + const denied = await fetch(`${origin}/native-directory-picker`, { method: "POST", headers }); + expect(denied.status).toBe(401); expect(choose).not.toHaveBeenCalled(); + const accepted = await fetch(`${origin}/native-directory-picker`, { method: "POST", headers: { + ...headers, "X-Webui-Token": info.credential.token, + } }); + expect(accepted.status).toBe(200); + expect(await accepted.json()).toEqual({ kind: "selected", directory: os.tmpdir() }); + await service.close(); expect(dispose).toHaveBeenCalledTimes(1); + }); + // Awaits the upgrade promise and asserts the rejection carries the // expected guard. The promise is consumed on every refusal path, so the // `ws` library's refused-handshake rejection never escapes as an diff --git a/release/public-source.json b/release/public-source.json index feff72b9f..c5aeac419 100644 --- a/release/public-source.json +++ b/release/public-source.json @@ -4415,6 +4415,7 @@ "packages/webui/src/client/platform/connection-health.ts", "packages/webui/src/client/platform/event-channel.ts", "packages/webui/src/client/platform/miniapp-frame-url.ts", + "packages/webui/src/client/platform/native-directory-picker.ts", "packages/webui/src/client/platform/no-project.ts", "packages/webui/src/client/platform/page-host.ts", "packages/webui/src/client/platform/session-import.ts", @@ -4652,6 +4653,7 @@ "packages/webui/src/server/http/browser-extension.ts", "packages/webui/src/server/http/client-assets.ts", "packages/webui/src/server/http/design-assets.ts", + "packages/webui/src/server/http/native-directory.ts", "packages/webui/src/server/http/responses.ts", "packages/webui/src/server/http/router.ts", "packages/webui/src/server/http/session-transfer.ts", @@ -5094,6 +5096,7 @@ "packages/webui/test/unit/models-catalogue-retention.test.ts", "packages/webui/test/unit/models-provider-intent.test.ts", "packages/webui/test/unit/models-workflows.test.ts", + "packages/webui/test/unit/native-directory-picker.test.ts", "packages/webui/test/unit/observation-scheduler.test.ts", "packages/webui/test/unit/output-error.test.tsx", "packages/webui/test/unit/outside-close.test.ts", @@ -5277,6 +5280,8 @@ "release/public-source.json", "release/webui-npm/README.md", "release/webui-npm/bin/mcode-webui.mjs", + "release/webui-npm/bin/native-directory-picker.mjs", + "release/webui-npm/bin/native-directory-picker.ps1", "release/webui-npm/package.json", "schemas/plugins/app-v1.schema.json", "schemas/plugins/host-binding-v1.schema.json", diff --git a/release/webui-npm/bin/mcode-webui.mjs b/release/webui-npm/bin/mcode-webui.mjs index 66a43b6af..59d90568d 100644 --- a/release/webui-npm/bin/mcode-webui.mjs +++ b/release/webui-npm/bin/mcode-webui.mjs @@ -256,7 +256,15 @@ const terminal = new WebuiTerminalManager(); // The bridge's pairings follow the switches, so the persisted authorization has // to reach them before the service starts serving. await browser.initialize(); +// Kept out of help/version and disabled for unattended, remote and full-access runs. +const { nativeDirectoryPickerEligible, createWindowsDirectoryPicker, nativeDirectoryLaunchUrl } = + await import("./native-directory-picker.mjs"); +const nativeDirectoryPicker = nativeDirectoryPickerEligible({ + platform: process.platform, tty: Boolean(process.stdout.isTTY), bindHost, + fullAccess: args["full-access"], browserSetting: process.env.WEBUI_OPEN_BROWSER, +}) ? createWindowsDirectoryPicker() : undefined; const service = new WebuiService({ + nativeDirectoryPicker, port, operations: createOperationRegistry(port, terminal, browser.port, browserBridge, miniappProxies, miniAppPresenter), terminal, @@ -289,9 +297,12 @@ const service = new WebuiService({ let closing; const close = () => { closing ??= (async () => { - await service.close(); - await browser.close(); - await assembled.host.apiHost.close(); + try { + await service.close(); + } finally { + try { await browser.close(); } + finally { await assembled.host.apiHost.close(); } + } })(); return closing; }; @@ -314,7 +325,8 @@ try { `[mcode-webui] Mini App port: ${miniappPort} — forward it, or a Mini App loads blank`, ); printAccess(info, bindHost); - openBrowser(browserUrl); + // Only the automatically opened local tab receives this separate ephemeral grant. + openBrowser(nativeDirectoryPicker ? nativeDirectoryLaunchUrl(browserUrl, nativeDirectoryPicker.grant) : browserUrl, browserUrl); console.log("Press Ctrl+C to stop the server."); process.once("SIGINT", () => void close().finally(() => process.exit(0))); process.once("SIGTERM", () => void close().finally(() => process.exit(0))); @@ -398,7 +410,7 @@ function lanAddresses() { * The server is already serving by this point, and failing the run because a * browser could not start would turn a convenience into an outage. */ -function openBrowser(url) { +function openBrowser(url, printableUrl = url) { const setting = process.env.WEBUI_OPEN_BROWSER?.trim().toLowerCase(); const disabled = setting === "0" || setting === "false" || setting === "no" || setting === "off" || setting === "never"; const enabled = setting === undefined || setting === "" ? Boolean(process.stdout.isTTY) : !disabled; @@ -415,14 +427,14 @@ function openBrowser(url) { try { const child = spawn(command, args, { stdio: "ignore", detached: true }); child.on("error", (error) => { - console.warn(`[mcode-webui] could not open a browser (${command}): ${error.message}`); - console.warn(`[mcode-webui] open ${url} yourself, or set WEBUI_OPEN_BROWSER=0 to stop this attempt.`); + console.warn(`[mcode-webui] could not open a browser (${command})`); + console.warn(`[mcode-webui] open ${printableUrl} yourself, or set WEBUI_OPEN_BROWSER=0 to stop this attempt.`); }); // Detached so the browser is not a child of this server: closing the page // must not signal the process, and stopping the server must not close the // page the person is still reading. child.unref(); } catch (error) { - console.warn(`[mcode-webui] could not open a browser (${command}): ${error.message}`); + console.warn(`[mcode-webui] could not open a browser (${command})`); } } diff --git a/release/webui-npm/bin/native-directory-picker.mjs b/release/webui-npm/bin/native-directory-picker.mjs new file mode 100644 index 000000000..791d6d865 --- /dev/null +++ b/release/webui-npm/bin/native-directory-picker.mjs @@ -0,0 +1,106 @@ +import { spawn } from 'node:child_process'; +import { randomUUID } from 'node:crypto'; +import { readFile } from 'node:fs/promises'; +import path from 'node:path'; + +export function nativeDirectoryPickerEligible({ platform, tty, bindHost, fullAccess, browserSetting }) { + const setting = browserSetting?.trim().toLowerCase(); + return platform === 'win32' && tty === true && !fullAccess + && ['127.0.0.1', '::1'].includes(bindHost) + && !['0', 'false', 'no', 'off', 'never'].includes(setting); +} + +export function nativeDirectoryLaunchUrl(url, grant) { + const result = new URL(url); + result.hash = new URLSearchParams({ nativeDirectoryGrant: grant }).toString(); + return result.href; +} + +// A narrow launcher-owned provider, never a shell/command execution endpoint. +export function createWindowsDirectoryPicker({ + spawnProcess = spawn, readScript = () => readFile(new URL('./native-directory-picker.ps1', import.meta.url), 'utf8'), + windowsRoot = process.env.SystemRoot, architecture = process.arch, +} = {}) { + let active; + let disposed = false; + const unavailable = () => new Error('Native folder selection is unavailable'); + return { + grant: randomUUID(), + async choose(signal) { + if (disposed || active || signal.aborted || !windowsRoot || !path.win32.isAbsolute(windowsRoot)) throw unavailable(); + let script; + try { script = await readScript(); } catch { throw unavailable(); } + if (disposed || active || signal.aborted) throw unavailable(); + // A 32-bit launcher must reach 64-bit Windows PowerShell, not its redirected SysWOW64 copy. + const system = architecture === 'ia32' ? 'Sysnative' : 'System32'; + const executable = path.win32.join(windowsRoot, system, 'WindowsPowerShell', 'v1.0', 'powershell.exe'); + return new Promise((resolve, reject) => { + let child; + let output = ''; + let settled = false; + let aborting = false; + let killWatchdog; + let markClosed; + const closed = new Promise((resolveClosed) => { markClosed = resolveClosed; }); + const finish = (error, result) => { + if (settled) return; + settled = true; + clearTimeout(timer); + clearTimeout(killWatchdog); + signal.removeEventListener('abort', abort); + if (error) reject(unavailable()); else resolve(result); + }; + const abort = () => { + if (aborting || settled) return; + aborting = true; + try { child?.kill('SIGKILL'); } catch { /* Never disclose process arguments. */ } + // Do not release the HTTP flight until the process actually closes. + // If termination cannot be confirmed, fail closed for this launcher's lifetime. + if (!settled) killWatchdog = setTimeout(() => { disposed = true; finish(unavailable()); }, 1000); + }; + // Independent bound also covers callers other than the HTTP service. + const timer = setTimeout(abort, 120_000); + try { + child = spawnProcess(executable, ['-NoLogo', '-NoProfile', '-NonInteractive', '-STA', '-EncodedCommand', + Buffer.from(script, 'utf16le').toString('base64')], { windowsHide: true, shell: false, stdio: ['ignore', 'pipe', 'ignore'] }); + active = { abort, closed }; + signal.addEventListener('abort', abort, { once: true }); + if (signal.aborted) abort(); + child.stdout.setEncoding('utf8'); + child.stdout.on('data', (chunk) => { + output += chunk.toString('utf8'); + if (Buffer.byteLength(output) > 32768) abort(); + }); + child.once('error', () => { + if (!child.pid) { active = undefined; markClosed(); } + finish(unavailable()); + }); + child.once('close', (code) => { + active = undefined; + markClosed(); + if (aborting || code !== 0) { finish(unavailable()); return; } + try { + const result = JSON.parse(output.replace(/^\uFEFF/, '').trim()); + if (result.kind === 'cancelled') finish(null, { kind: 'cancelled' }); + else if (result.kind === 'selected' && typeof result.directory === 'string' + && path.win32.isAbsolute(result.directory) && !/[\0\r\n]/.test(result.directory)) { + finish(null, { kind: 'selected', directory: result.directory }); + } else finish(unavailable()); + } catch { finish(unavailable()); } + }); + } catch { active = undefined; finish(unavailable()); } + }); + }, + async dispose() { + disposed = true; + const pending = active; + if (!pending) return; + pending.abort(); + // A stuck child cannot indefinitely block service shutdown. No later choose is admitted. + await new Promise((resolve, reject) => { + const timer = setTimeout(() => reject(unavailable()), 1000); + pending.closed.then(() => { clearTimeout(timer); resolve(); }); + }); + }, + }; +} diff --git a/release/webui-npm/bin/native-directory-picker.ps1 b/release/webui-npm/bin/native-directory-picker.ps1 new file mode 100644 index 000000000..e8f8c886d --- /dev/null +++ b/release/webui-npm/bin/native-directory-picker.ps1 @@ -0,0 +1,64 @@ +# Fixed launcher-owned program. No request text is accepted as code or arguments. +$ErrorActionPreference = 'Stop' +[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false) +if (-not [Environment]::UserInteractive -or [Diagnostics.Process]::GetCurrentProcess().SessionId -eq 0) { exit 3 } +Add-Type -TypeDefinition @' +using System; +using System.Runtime.InteropServices; +namespace WebuiFolderPicker { + [ComImport, Guid("DC1C5A9C-E88A-4DDE-A5A1-60F82A20AEF7")] class FileOpenDialog {} + [ComImport, Guid("42F85136-DB7E-439C-85F1-E4075D135FC8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + interface IFileDialog { + [PreserveSig] int Show(IntPtr owner); + void SetFileTypes(uint count, IntPtr filters); + void SetFileTypeIndex(uint index); + void GetFileTypeIndex(out uint index); + void Advise(IntPtr events, out uint cookie); + void Unadvise(uint cookie); + void SetOptions(uint options); + void GetOptions(out uint options); + void SetDefaultFolder(IShellItem item); + void SetFolder(IShellItem item); + void GetFolder(out IShellItem item); + void GetCurrentSelection(out IShellItem item); + void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string name); + void GetFileName(out IntPtr name); + void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string title); + void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string label); + void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string label); + void GetResult(out IShellItem item); + } + [ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + interface IShellItem { + void BindToHandler(IntPtr context, ref Guid handler, ref Guid iid, out IntPtr result); + void GetParent(out IShellItem parent); + void GetDisplayName(uint name, out IntPtr result); + void GetAttributes(uint mask, out uint attributes); + void Compare(IShellItem other, uint hint, out int order); + } + public static class Picker { + public static string Choose() { + object instance = new FileOpenDialog(); IShellItem item = null; IntPtr name = IntPtr.Zero; + try { + var dialog = (IFileDialog)instance; + uint flags; dialog.GetOptions(out flags); + // PICKFOLDERS | FORCEFILESYSTEM | PATHMUSTEXIST | DONTADDTORECENT. + dialog.SetOptions(flags | 0x20u | 0x40u | 0x800u | 0x2000000u); + int result = dialog.Show(IntPtr.Zero); + if (result == unchecked((int)0x800704C7)) return null; + Marshal.ThrowExceptionForHR(result); + dialog.GetResult(out item); item.GetDisplayName(0x80058000u, out name); + return Marshal.PtrToStringUni(name); + } finally { + if (name != IntPtr.Zero) Marshal.FreeCoTaskMem(name); + if (item != null) Marshal.FinalReleaseComObject(item); + Marshal.FinalReleaseComObject(instance); + } + } + } +'@ +try { + $directory = [WebuiFolderPicker.Picker]::Choose() + if ($null -eq $directory) { '{"kind":"cancelled"}' } + else { @{kind='selected';directory=$directory} | ConvertTo-Json -Compress } +} catch { exit 3 } diff --git a/test/source-sync.test.mjs b/test/source-sync.test.mjs index 4b324116e..3ad68fc1d 100644 --- a/test/source-sync.test.mjs +++ b/test/source-sync.test.mjs @@ -1511,3 +1511,112 @@ test('the desktop version the marketplace is filtered by is declared in exactly ); assert.deepEqual(offenders, [], 'the declared desktop version is written in the shared module only'); }); + +test('native folder launcher grant is restricted to authenticated interactive Windows loopback', async () => { + const { nativeDirectoryPickerEligible: eligible, nativeDirectoryLaunchUrl } = await import('../release/webui-npm/bin/native-directory-picker.mjs'); + const local = { platform: 'win32', tty: true, bindHost: '127.0.0.1', fullAccess: false }; + assert.equal(eligible(local), true); + for (const change of [{ platform: 'linux' }, { platform: 'darwin' }, { tty: false }, { fullAccess: true }, { bindHost: '0.0.0.0' }, { bindHost: '192.168.1.1' }, { browserSetting: 'off' }]) { + assert.equal(eligible({ ...local, ...change }), false); + } + assert.equal(eligible({ ...local, tty: false, browserSetting: '1' }), false); + const plain = 'http://127.0.0.1:2233/?token=fixture'; + const granted = nativeDirectoryLaunchUrl(plain, 'synthetic-native-grant'); + assert.equal(granted.split('#')[0], plain); + assert.equal(new URLSearchParams(new URL(granted).hash.slice(1)).get('nativeDirectoryGrant'), 'synthetic-native-grant'); + const launcher = readFileSync(new URL('../release/webui-npm/bin/mcode-webui.mjs', import.meta.url), 'utf8'); + assert.match(launcher, /openBrowser\(nativeDirectoryPicker \? nativeDirectoryLaunchUrl\(browserUrl, nativeDirectoryPicker.grant\) : browserUrl, browserUrl\)/); + assert.doesNotMatch(launcher, /console\.(?:log|warn|error)\([^\n]*(?:nativeDirectoryPicker.grant|\$\{url\}|error.message)/); +}); + +test('native folder chooser uses a fixed STA program and narrow selected/cancel results', async () => { + const { EventEmitter } = await import('node:events'); + const { PassThrough } = await import('node:stream'); + const { createWindowsDirectoryPicker } = await import('../release/webui-npm/bin/native-directory-picker.mjs'); + let child; let invocation; + const picker = createWindowsDirectoryPicker({ windowsRoot: 'C:\\Windows', architecture: 'ia32', readScript: async () => 'fixed script', spawnProcess: (...args) => { + invocation = args; child = new EventEmitter(); child.stdout = new PassThrough(); child.kill = () => true; return child; + } }); + const selected = picker.choose(new AbortController().signal); + await Promise.resolve(); + assert.match(invocation[0], /Sysnative\\WindowsPowerShell\\v1.0\\powershell.exe$/); + assert.deepEqual(invocation[1].slice(0, 5), ['-NoLogo', '-NoProfile', '-NonInteractive', '-STA', '-EncodedCommand']); + assert.equal(Buffer.from(invocation[1][5], 'base64').toString('utf16le'), 'fixed script'); + assert.equal(invocation[2].shell, false); + child.stdout.write(JSON.stringify({ kind: 'selected', directory: 'D:\\项目\\work' })); child.emit('close', 0); + assert.deepEqual(await selected, { kind: 'selected', directory: 'D:\\项目\\work' }); + const cancelled = picker.choose(new AbortController().signal); await Promise.resolve(); + child.stdout.write('{"kind":"cancelled"}'); child.emit('close', 0); + assert.deepEqual(await cancelled, { kind: 'cancelled' }); + await picker.dispose(); + await assert.rejects(picker.choose(new AbortController().signal), /unavailable/); + const script = readFileSync(new URL('../release/webui-npm/bin/native-directory-picker.ps1', import.meta.url), 'utf8'); + assert.match(script, /UserInteractive/); assert.match(script, /SessionId -eq 0/); + assert.match(script, /0x20u \| 0x40u \| 0x800u \| 0x2000000u/); + assert.match(script, /0x800704C7/); assert.match(script, /dialog.Show\(IntPtr.Zero\)/); + assert.doesNotMatch(script, /\$args|Invoke-Expression|Start-Process/); +}); + +test('native folder abort kills its child and keeps it busy until close; failures disclose no output', async () => { + const { EventEmitter } = await import('node:events'); + const { PassThrough } = await import('node:stream'); + const { createWindowsDirectoryPicker } = await import('../release/webui-npm/bin/native-directory-picker.mjs'); + let child; let killed = 0; + const picker = createWindowsDirectoryPicker({ windowsRoot: 'C:\\Windows', readScript: async () => 'fixed', spawnProcess: () => { + child = new EventEmitter(); child.stdout = new PassThrough(); child.kill = () => { killed++; return true; }; return child; + } }); + const controller = new AbortController(); const pending = picker.choose(controller.signal); await Promise.resolve(); + let settled = false; + pending.then(() => { settled = true; }, () => { settled = true; }); + const rejection = assert.rejects(pending, /^Error: Native folder selection is unavailable$/); + controller.abort(); + assert.equal(killed, 1); + await Promise.resolve(); assert.equal(settled, false); + await assert.rejects(picker.choose(new AbortController().signal), /unavailable/); + child.emit('close', 1); await rejection; + const malformed = picker.choose(new AbortController().signal); await Promise.resolve(); + child.stdout.write('private-path-or-error'); child.emit('close', 0); + await assert.rejects(malformed, /^Error: Native folder selection is unavailable$/); + await picker.dispose(); +}); + +test('native folder chooser rejects pre-abort and malformed output and waits for disposal close', async () => { + const { EventEmitter } = await import('node:events'); + const { PassThrough } = await import('node:stream'); + const { createWindowsDirectoryPicker } = await import('../release/webui-npm/bin/native-directory-picker.mjs'); + let child; let launches = 0; + const picker = createWindowsDirectoryPicker({ windowsRoot: 'C:\\Windows', readScript: async () => 'fixed', spawnProcess: () => { + launches++; child = new EventEmitter(); child.stdout = new PassThrough(); child.kill = () => true; return child; + } }); + const aborted = new AbortController(); aborted.abort(); + await assert.rejects(picker.choose(aborted.signal), /unavailable/); assert.equal(launches, 0); + for (const output of ['{"kind":"selected","directory":"relative"}', '{"kind":"unexpected"}']) { + const pending = picker.choose(new AbortController().signal); await Promise.resolve(); + child.stdout.write(output); child.emit('close', 0); + await assert.rejects(pending, /unavailable/); + } + const pending = picker.choose(new AbortController().signal); await Promise.resolve(); + const rejected = assert.rejects(pending, /unavailable/); + let disposed = false; + const disposal = picker.dispose().then(() => { disposed = true; }); + await Promise.resolve(); assert.equal(disposed, false); + child.emit('close', 1); await rejected; await disposal; assert.equal(disposed, true); +}); + +test('native folder termination watchdog permanently fails closed if the process does not exit', async () => { + const { EventEmitter } = await import('node:events'); + const { PassThrough } = await import('node:stream'); + const { createWindowsDirectoryPicker } = await import('../release/webui-npm/bin/native-directory-picker.mjs'); + let child; let kills = 0; + const picker = createWindowsDirectoryPicker({ windowsRoot: 'C:\\Windows', readScript: async () => 'fixed', spawnProcess: () => { + child = new EventEmitter(); child.stdout = new PassThrough(); child.kill = () => { kills++; return false; }; return child; + } }); + const controller = new AbortController(); + const pending = picker.choose(controller.signal); await Promise.resolve(); + const rejected = assert.rejects(pending, /unavailable/); + controller.abort(); await rejected; + assert.equal(kills, 1); + child.emit('close', 1); + await assert.rejects(picker.choose(new AbortController().signal), /unavailable/); + await picker.dispose(); +}); diff --git a/test/vitest-suites.json b/test/vitest-suites.json index b984a413d..1f7911dab 100644 --- a/test/vitest-suites.json +++ b/test/vitest-suites.json @@ -532,6 +532,7 @@ "packages/webui/test/unit/webui-workspace-file-tree.test.tsx", "packages/webui/test/unit/webui-workspace-html-preview.test.tsx", "packages/webui/test/unit/webui-workspace-media-preview.test.tsx", + "packages/webui/test/unit/native-directory-picker.test.ts", "packages/webui/test/unit/workspace-directory-browser.test.ts", "packages/webui/test/unit/workspace-panel-state.test.ts", "packages/webui/test/unit/workspace-queries.test.ts",