@qwen-code/qwen-code 0.22.3 → 0.23.0

package/chunks/{chunk-4NDLQAY2.js → chunk-SI7WDR3U.js}

@@ -2,10 +2,7 @@
 "use strict";
 import {
   parseToolWriteOriginMeta
-} from "./chunk-U54AYGEC.js";
-import {
-  isLoopbackBind
-} from "./chunk-RXFQM6FQ.js";
+} from "./chunk-VGHZT6JR.js";
 import {
   MAX_CHILD_HEAP_MB,
   MIN_CHILD_HEAP_MB,
@@ -14,13 +11,17 @@ import {
 import {
   CLIENT_ID_RE,
   MAX_CLIENT_ID_LENGTH
-} from "./chunk-SEONHUS3.js";
+} from "./chunk-LAUEEBDL.js";
 import {
   isInternalWorkspaceRuntime
 } from "./chunk-NYWWQ437.js";
+import {
+  formatHostForAuthority,
+  isLoopbackBind
+} from "./chunk-DMEUXLSS.js";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
-} from "./chunk-OZ6KS6KW.js";
+} from "./chunk-ZGCKTAL5.js";
 import {
   ROOT_CONTEXT,
   context,
@@ -773,8 +774,8 @@ var DeviceFlowRegistry = class {
   /**
    * For diagnostics / GET /workspace/auth/status: report only pending
    * flows. Terminal entries are an implementation detail of the SDK
-   * reconnect path and shouldn't be enumerated to all bearer-token
-   * holders.
+   * reconnect path and shouldn't be enumerated to all authorized status
+   * callers.
    */
   listPending() {
     const out = [];
@@ -919,6 +920,67 @@ function isDeepHealthQuery(raw) {
 }
 __name(isDeepHealthQuery, "isDeepHealthQuery");
 
+// packages/cli/src/serve/server/self-origin.ts
+init_esbuild_shims();
+function installSelfOriginStripMiddleware(app, getPort, bind) {
+  let cachedStripPort = -1;
+  let cachedSelfOrigins = /* @__PURE__ */ new Set();
+  const boundHost = isLoopbackBind(bind) ? formatHostForAuthority(bind) : void 0;
+  app.use((req, _res, next) => {
+    const origin = req.headers.origin;
+    if (origin) {
+      const port = getPort();
+      if (port !== cachedStripPort) {
+        cachedStripPort = port;
+        cachedSelfOrigins = /* @__PURE__ */ new Set([
+          `http://127.0.0.1:${port}`,
+          `http://localhost:${port}`,
+          `http://[::1]:${port}`,
+          `http://host.docker.internal:${port}`,
+          `https://127.0.0.1:${port}`,
+          `https://localhost:${port}`,
+          `https://[::1]:${port}`,
+          `https://host.docker.internal:${port}`
+        ]);
+        if (boundHost) {
+          cachedSelfOrigins.add(`http://${boundHost}:${port}`);
+          cachedSelfOrigins.add(`https://${boundHost}:${port}`);
+        }
+        if (port === 80) {
+          for (const host of [
+            "127.0.0.1",
+            "localhost",
+            "[::1]",
+            "host.docker.internal"
+          ]) {
+            cachedSelfOrigins.add(`http://${host}`);
+          }
+          if (boundHost) {
+            cachedSelfOrigins.add(`http://${boundHost}`);
+          }
+        } else if (port === 443) {
+          for (const host of [
+            "127.0.0.1",
+            "localhost",
+            "[::1]",
+            "host.docker.internal"
+          ]) {
+            cachedSelfOrigins.add(`https://${host}`);
+          }
+          if (boundHost) {
+            cachedSelfOrigins.add(`https://${boundHost}`);
+          }
+        }
+      }
+      if (cachedSelfOrigins.has(origin)) {
+        delete req.headers.origin;
+      }
+    }
+    next();
+  });
+}
+__name(installSelfOriginStripMiddleware, "installSelfOriginStripMiddleware");
+
 // packages/cli/src/serve/acp-child-extra-args.ts
 init_esbuild_shims();
 function acpChildExtraArgs(opts) {
@@ -1078,6 +1140,16 @@ function parseAllowOriginPatterns(raw) {
   return { allowAny, origins };
 }
 __name(parseAllowOriginPatterns, "parseAllowOriginPatterns");
+function findNonLoopbackHttpOrigin(patterns) {
+  for (const origin of patterns.origins) {
+    const parsed = new URL(origin);
+    if ((parsed.protocol === "http:" || parsed.protocol === "https:") && !isLoopbackBind(parsed.hostname)) {
+      return origin;
+    }
+  }
+  return void 0;
+}
+__name(findNonLoopbackHttpOrigin, "findNonLoopbackHttpOrigin");
 var MutableOriginAllowlist = class {
   static {
     __name(this, "MutableOriginAllowlist");
@@ -1173,6 +1245,7 @@ function buildPrimaryHostGate(bind, getPort) {
   }
   let cachedPort = -1;
   let cachedAllowed = /* @__PURE__ */ new Set();
+  const boundHost = formatHostForAuthority(bind);
   const allowedFor = /* @__PURE__ */ __name((port) => {
     if (port === cachedPort) return cachedAllowed;
     cachedPort = port;
@@ -1180,13 +1253,15 @@ function buildPrimaryHostGate(bind, getPort) {
       `localhost:${port}`,
       `127.0.0.1:${port}`,
       `[::1]:${port}`,
-      `host.docker.internal:${port}`
+      `host.docker.internal:${port}`,
+      `${boundHost}:${port}`
     ]);
     if (port === 80 || port === 443) {
       cachedAllowed.add("localhost");
       cachedAllowed.add("127.0.0.1");
       cachedAllowed.add("[::1]");
       cachedAllowed.add("host.docker.internal");
+      cachedAllowed.add(boundHost);
     }
     return cachedAllowed;
   }, "allowedFor");
@@ -1247,13 +1322,22 @@ function requestWasAuthenticated(req) {
   return req[AUTHENTICATED_REQUEST] === true;
 }
 __name(requestWasAuthenticated, "requestWasAuthenticated");
+function isTrustedLoopbackMode(input) {
+  return input.loopbackBind && !input.tokenConfigured && !input.requireAuth;
+}
+__name(isTrustedLoopbackMode, "isTrustedLoopbackMode");
+function requestHasOperatorAuthority(req, trustedLoopbackMode) {
+  return requestWasAuthenticated(req) || trustedLoopbackMode && listenerIdentityOf(req).kind === "primary";
+}
+__name(requestHasOperatorAuthority, "requestHasOperatorAuthority");
 function createMutationGate(deps) {
   const passthrough = /* @__PURE__ */ __name((_req, _res, next) => next(), "passthrough");
-  if (deps.requireAuth || deps.tokenConfigured) {
+  if (deps.tokenConfigured) {
     return () => passthrough;
   }
+  const trustedLoopbackMode = deps.trustedLoopbackMode === true && deps.requireAuth === false;
   const strictDenier = /* @__PURE__ */ __name((req, res, next) => {
-    if (requestWasAuthenticated(req)) {
+    if (requestHasOperatorAuthority(req, trustedLoopbackMode)) {
       next();
       return;
     }
@@ -1484,7 +1568,17 @@ var SERVE_CAPABILITY_REGISTRY = {
     since: "v1",
     modes: ["workspace", "clean"]
   },
+  // Explicit remember targets and scoped forget (`scope` parameter). Old
+  // daemons silently ignore an unknown `scope`, so the SDK pre-flights the
+  // matching tag before sending one. The sibling no-op behavior change — a
+  // zero-write remember now fails `remember_no_update` instead of completing
+  // with 'No memory files updated.' — is deliberately untagged: it changes a
+  // task's terminal outcome, not the surface shape, and every client sees it
+  // as a typed `failed` task status that cannot be mistaken for success.
+  workspace_memory_remember_project_scope: { since: "v1" },
+  workspace_memory_remember_user_scope: { since: "v1" },
   workspace_memory_forget: { since: "v1" },
+  workspace_memory_forget_scope: { since: "v1" },
   workspace_memory_dream: { since: "v1" },
   // Workspace agents CRUD (`GET/POST /workspace/agents` +
   // `GET/POST/DELETE /workspace/agents/:agentType`). Wraps
@@ -1511,6 +1605,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_organization: { since: "v1" },
   session_export: { since: "v1" },
   standalone_sessions_v1: { since: "v1" },
+  standalone_session_options_v1: { since: "v1" },
   session_transcript: { since: "v1" },
   session_transcript_pagination: { since: "v1" },
   // Daemon supports the MCP client guardrail surface: an in-process
@@ -1645,8 +1740,8 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_btw: { since: "v1" },
   // Direct daemon-side shell execution for an existing session.
   // Advertised CONDITIONALLY: operators must explicitly enable it and
-  // configure bearer auth. Clients must still send a session-bound
-  // X-Qwen-Client-Id when calling the route.
+  // either configure bearer auth or use trusted-loopback mode. Clients must
+  // still send a session-bound X-Qwen-Client-Id when calling the route.
   session_shell_command: { since: "v1" },
   // Daemon hosts a workspace-shared MCP transport
   // pool (`QwenAgent.mcpPool`); `GET /workspace/mcp` reflects pool-level
@@ -1705,6 +1800,12 @@ var SERVE_CAPABILITY_REGISTRY = {
   writer_idle_timeout: { since: "v1" },
   non_blocking_prompt: { since: "v1" },
   session_language: { since: "v1" },
+  // Sessionless user-level language sync (`POST /language`) for hosts that
+  // switch language before any session exists (issue #10234). Advertised
+  // CONDITIONALLY with `workspace_settings`: the route persists user-scope
+  // settings, so daemons without settings persistence omit the tag and
+  // return 404.
+  user_language_sync: { since: "v1" },
   session_rewind: { since: "v1" },
   workspace_hooks: { since: "v1" },
   session_hooks: { since: "v1" },
@@ -1744,6 +1845,25 @@ var SERVE_CAPABILITY_REGISTRY = {
   workspace_display_name: { since: "v1" },
   scratch_workspace_registration: { since: "v1" },
   workspace_runtime_removal: { since: "v1" },
+  // A native OS directory picker can be opened on the daemon host
+  // (osascript on macOS, PowerShell on Windows, zenity on a Linux host
+  // with a display). Headless hosts omit the tag so clients hide the
+  // Browse affordance instead of surfacing a guaranteed picker failure.
+  native_directory_picker: { since: "v1" },
+  // Workspace-owned runtime lifecycle status and explicit on-demand startup.
+  workspace_runtime: { since: "v1" },
+  // The daemon host can open a workspace directory in the host's OS file
+  // manager (Finder via `open` on macOS, Explorer via `explorer.exe` on
+  // Windows, xdg-open on a Linux host with a display). Headless hosts omit
+  // the tag so clients hide the Open-locally affordance instead of
+  // surfacing a guaranteed launch failure.
+  workspace_local_open: { since: "v1" },
+  // The daemon host can open a terminal window in a workspace directory
+  // (`open -a Terminal` on macOS, wt.exe/cmd.exe on Windows, a common
+  // terminal emulator on a Linux host with a display). Headless hosts omit
+  // the tag so clients hide the Open-in-terminal affordance instead of
+  // surfacing a guaranteed launch failure.
+  workspace_local_terminal: { since: "v1" },
   // Workspace-qualified core REST routes under `/workspaces/:workspace/...`.
   // Covers core file read/write/upload, status/permissions/trust/lifecycle/MCP/tool,
   // memory, workspace agent CRUD, and persisted session organization surfaces.
@@ -1767,6 +1887,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   // projections. This is additive to the legacy primary-workspace
   // `workspace_extensions` contract.
   extension_management_v2: { since: "v1" },
+  extension_state: { since: "v1" },
   extension_git_credentials: { since: "v1" },
   extension_local_path_install: { since: "v1" },
   // Workspace-qualified, daemon-local persisted transcript paging. The tag is
@@ -1843,6 +1964,10 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
     "standalone_sessions_v1",
     (toggles) => toggles.standaloneSessionsAvailable === true
   ],
+  [
+    "standalone_session_options_v1",
+    (toggles) => toggles.standaloneSessionsAvailable === true
+  ],
   ["mcp_workspace_pool", (toggles) => toggles.mcpPoolActive === true],
   ["mcp_pool_restart", (toggles) => toggles.mcpPoolActive === true],
   [
@@ -1859,6 +1984,7 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
     (toggles) => typeof toggles.writerIdleTimeoutMs === "number" && toggles.writerIdleTimeoutMs > 0
   ],
   ["workspace_settings", (toggles) => toggles.persistSettingAvailable === true],
+  ["user_language_sync", (toggles) => toggles.persistSettingAvailable === true],
   ["workspace_voice", (toggles) => toggles.persistSettingAvailable === true],
   [
     "workspace_voice_transcription",
@@ -1924,6 +2050,22 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
     "workspace_runtime_removal",
     (toggles) => toggles.workspaceRuntimeRemovalAvailable === true
   ],
+  [
+    "native_directory_picker",
+    (toggles) => toggles.nativeDirectoryPickerAvailable === true
+  ],
+  [
+    "workspace_runtime",
+    (toggles) => toggles.workspaceRuntimeAvailable === true
+  ],
+  [
+    "workspace_local_open",
+    (toggles) => toggles.localPathOpenAvailable === true
+  ],
+  [
+    "workspace_local_terminal",
+    (toggles) => toggles.localTerminalOpenAvailable === true
+  ],
   [
     "workspace_qualified_acp",
     // The plural routes are pre-mounted for workspaces registered after app
@@ -1991,6 +2133,360 @@ function getServeProtocolVersions() {
 }
 __name(getServeProtocolVersions, "getServeProtocolVersions");
 
+// packages/cli/src/serve/native-directory-picker.ts
+init_esbuild_shims();
+import { execFile } from "node:child_process";
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var PICKER_TIMEOUT_MS = 3e5;
+var NativeDirectoryPickerUnavailableError = class extends Error {
+  static {
+    __name(this, "NativeDirectoryPickerUnavailableError");
+  }
+};
+function isNativeDirectoryPickerAvailable(env = process.env, macOsSessionUids = process.platform === "darwin" ? readMacOsSessionUids() : void 0) {
+  if (process.platform === "darwin") {
+    return macOsSessionUids?.processUid !== void 0 && macOsSessionUids.processUid > 0 && macOsSessionUids.consoleUid === macOsSessionUids.processUid && !env["SSH_CONNECTION"] && !env["SSH_TTY"];
+  }
+  if (process.platform === "win32") {
+    const sessionName = env["SESSIONNAME"]?.trim();
+    return Boolean(sessionName && sessionName.toLowerCase() !== "services");
+  }
+  if (process.platform !== "linux") return false;
+  if (!env["DISPLAY"] && !env["WAYLAND_DISPLAY"]) return false;
+  return (env["PATH"] ?? "").split(delimiter).some((dir) => dir !== "" && isExecutableFile(join(dir, "zenity")));
+}
+__name(isNativeDirectoryPickerAvailable, "isNativeDirectoryPickerAvailable");
+function readMacOsSessionUids() {
+  try {
+    return {
+      processUid: process.getuid?.(),
+      consoleUid: statSync("/dev/console").uid
+    };
+  } catch {
+    return {};
+  }
+}
+__name(readMacOsSessionUids, "readMacOsSessionUids");
+function isExecutableFile(file) {
+  try {
+    if (!statSync(file).isFile()) return false;
+    accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isExecutableFile, "isExecutableFile");
+async function pickNativeDirectory(signal) {
+  try {
+    if (process.platform === "darwin") {
+      const script = [
+        "const app = Application.currentApplication();",
+        "app.includeStandardAdditions = true;",
+        "app.chooseFolder({",
+        'withPrompt: "Select a workspace folder",',
+        "}).toString();"
+      ].join(" ");
+      const { stdout } = await execFileAsync(
+        "osascript",
+        ["-l", "JavaScript", "-e", script],
+        { timeout: PICKER_TIMEOUT_MS, signal }
+      );
+      return stdout.trim() || void 0;
+    }
+    if (process.platform === "win32") {
+      const script = [
+        "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8;",
+        "Add-Type -AssemblyName System.Windows.Forms;",
+        "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog;",
+        "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
+        "[Console]::Out.Write($dialog.SelectedPath)",
+        "}"
+      ].join(" ");
+      const { stdout } = await execFileAsync(
+        "powershell.exe",
+        ["-NoProfile", "-STA", "-Command", script],
+        { timeout: PICKER_TIMEOUT_MS, signal }
+      );
+      return stdout.trim() || void 0;
+    }
+    if (process.platform === "linux") {
+      const { stdout } = await execFileAsync(
+        "zenity",
+        [
+          "--file-selection",
+          "--directory",
+          "--title=Select a workspace folder"
+        ],
+        { timeout: PICKER_TIMEOUT_MS, signal }
+      );
+      return stdout.trim() || void 0;
+    }
+  } catch (error) {
+    const result = error;
+    if (result.killed) {
+      return void 0;
+    }
+    if (process.platform === "darwin" && (result.stderr?.includes("(-128)") || result.stderr?.includes("User canceled")) || // Zenity exits 1 both for a deliberate cancel and for "cannot open
+    // display" on headless Linux; only the former is a silent cancel.
+    process.platform === "linux" && result.code === 1 && !result.stderr?.includes("cannot open display")) {
+      return void 0;
+    }
+    throw new NativeDirectoryPickerUnavailableError(
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  throw new NativeDirectoryPickerUnavailableError(
+    `Native directory picker is not supported on ${process.platform}`
+  );
+}
+__name(pickNativeDirectory, "pickNativeDirectory");
+
+// packages/cli/src/serve/local-path-open.ts
+init_esbuild_shims();
+import { execFile as execFile2, spawn } from "node:child_process";
+import { accessSync as accessSync2, constants as constants2, statSync as statSync2 } from "node:fs";
+import { delimiter as delimiter2, join as join2 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var OPEN_TIMEOUT_MS = 1e4;
+var LINUX_TERMINAL_NAMES = ["gnome-terminal", "konsole", "xterm"];
+function linuxTerminalCandidates(env) {
+  return env["DISPLAY"] ? LINUX_TERMINAL_NAMES : LINUX_TERMINAL_NAMES.filter((name) => name !== "xterm");
+}
+__name(linuxTerminalCandidates, "linuxTerminalCandidates");
+var LocalPathOpenUnavailableError = class extends Error {
+  static {
+    __name(this, "LocalPathOpenUnavailableError");
+  }
+};
+var SpawnHangError = class extends Error {
+  static {
+    __name(this, "SpawnHangError");
+  }
+};
+function defaultMacOsSessionUids() {
+  return process.platform === "darwin" ? readMacOsSessionUids2() : void 0;
+}
+__name(defaultMacOsSessionUids, "defaultMacOsSessionUids");
+function hasGuiSession(env, macOsSessionUids) {
+  if (process.platform === "darwin") {
+    return macOsSessionUids?.processUid !== void 0 && macOsSessionUids.processUid > 0 && macOsSessionUids.consoleUid === macOsSessionUids.processUid && !env["SSH_CONNECTION"] && !env["SSH_TTY"];
+  }
+  if (process.platform === "win32") {
+    const sessionName = env["SESSIONNAME"]?.trim();
+    return Boolean(sessionName && sessionName.toLowerCase() !== "services");
+  }
+  return void 0;
+}
+__name(hasGuiSession, "hasGuiSession");
+function findExecutableOnPath(env, names) {
+  for (const name of names) {
+    for (const dir of (env["PATH"] ?? "").split(delimiter2)) {
+      if (dir === "") continue;
+      const candidate = join2(dir, name);
+      if (isExecutableFile2(candidate)) return candidate;
+    }
+  }
+  return void 0;
+}
+__name(findExecutableOnPath, "findExecutableOnPath");
+function isLocalPathOpenAvailable(env = process.env, macOsSessionUids = defaultMacOsSessionUids()) {
+  const guiSession = hasGuiSession(env, macOsSessionUids);
+  if (guiSession !== void 0) return guiSession;
+  if (process.platform !== "linux") return false;
+  if (!env["DISPLAY"] && !env["WAYLAND_DISPLAY"]) return false;
+  return findExecutableOnPath(env, ["xdg-open"]) !== void 0;
+}
+__name(isLocalPathOpenAvailable, "isLocalPathOpenAvailable");
+function isLocalTerminalAvailable(env = process.env, macOsSessionUids = defaultMacOsSessionUids()) {
+  const guiSession = hasGuiSession(env, macOsSessionUids);
+  if (guiSession !== void 0) return guiSession;
+  if (process.platform !== "linux") return false;
+  if (!env["DISPLAY"] && !env["WAYLAND_DISPLAY"]) return false;
+  return findExecutableOnPath(env, linuxTerminalCandidates(env)) !== void 0;
+}
+__name(isLocalTerminalAvailable, "isLocalTerminalAvailable");
+function readMacOsSessionUids2() {
+  try {
+    return {
+      processUid: process.getuid?.(),
+      consoleUid: statSync2("/dev/console").uid
+    };
+  } catch {
+    return {};
+  }
+}
+__name(readMacOsSessionUids2, "readMacOsSessionUids");
+function isExecutableFile2(file) {
+  try {
+    if (!statSync2(file).isFile()) return false;
+    accessSync2(file, constants2.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isExecutableFile2, "isExecutableFile");
+async function openPathLocally(path, timeoutMs) {
+  try {
+    if (process.platform === "darwin") {
+      await execFileAsync2("open", [path], { timeout: OPEN_TIMEOUT_MS });
+      return;
+    }
+    if (process.platform === "win32") {
+      assertPathExists(path);
+      await spawnAndIgnoreExitCode("explorer.exe", [path], { timeoutMs });
+      return;
+    }
+    if (process.platform === "linux") {
+      await execFileAsync2("xdg-open", [path], { timeout: OPEN_TIMEOUT_MS });
+      return;
+    }
+  } catch (error) {
+    throw new LocalPathOpenUnavailableError(
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  throw new LocalPathOpenUnavailableError(
+    `Local path open is not supported on ${process.platform}`
+  );
+}
+__name(openPathLocally, "openPathLocally");
+function assertPathExists(path) {
+  try {
+    statSync2(path);
+  } catch {
+    throw new LocalPathOpenUnavailableError(`Path does not exist: ${path}`);
+  }
+}
+__name(assertPathExists, "assertPathExists");
+async function openTerminalLocally(path, timeoutMs) {
+  try {
+    if (process.platform === "darwin") {
+      await execFileAsync2("open", ["-a", "Terminal", path], {
+        timeout: OPEN_TIMEOUT_MS
+      });
+      return;
+    }
+    if (process.platform === "win32") {
+      assertPathExists(path);
+      await spawnWindowsTerminal(path, timeoutMs);
+      return;
+    }
+    if (process.platform === "linux") {
+      assertPathExists(path);
+      await spawnLinuxTerminal(path, timeoutMs);
+      return;
+    }
+  } catch (error) {
+    if (error instanceof LocalPathOpenUnavailableError) throw error;
+    throw new LocalPathOpenUnavailableError(
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  throw new LocalPathOpenUnavailableError(
+    `Local terminal open is not supported on ${process.platform}`
+  );
+}
+__name(openTerminalLocally, "openTerminalLocally");
+async function spawnWindowsTerminal(path, timeoutMs) {
+  try {
+    await spawnAndIgnoreExitCode("wt.exe", ["-d", path], { timeoutMs });
+  } catch (error) {
+    if (error instanceof SpawnHangError) throw error;
+    await spawnAndIgnoreExitCode(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-STA",
+        "-Command",
+        'Start-Process cmd.exe -WorkingDirectory "$env:QWEN_LOCAL_OPEN_DIR"'
+      ],
+      { extraEnv: { QWEN_LOCAL_OPEN_DIR: path }, timeoutMs }
+    );
+  }
+}
+__name(spawnWindowsTerminal, "spawnWindowsTerminal");
+async function spawnLinuxTerminal(path, timeoutMs) {
+  const env = process.env;
+  if (!env["DISPLAY"] && !env["WAYLAND_DISPLAY"]) {
+    throw new LocalPathOpenUnavailableError("No display server available");
+  }
+  const terminal = findExecutableOnPath(env, linuxTerminalCandidates(env));
+  if (terminal === void 0) {
+    throw new LocalPathOpenUnavailableError(
+      "No terminal emulator found on PATH"
+    );
+  }
+  const name = terminal.split(/[\\/]/).pop();
+  if (name === "gnome-terminal") {
+    await spawnLongLived(terminal, [`--working-directory=${path}`], timeoutMs);
+    return;
+  }
+  if (name === "konsole") {
+    await spawnLongLived(terminal, ["--workdir", path], timeoutMs);
+    return;
+  }
+  await spawnLongLived(
+    terminal,
+    ["-e", "sh", "-c", 'cd "$1" && exec "${SHELL:-/bin/sh}"', "sh", path],
+    timeoutMs
+  );
+}
+__name(spawnLinuxTerminal, "spawnLinuxTerminal");
+function spawnAndIgnoreExitCode(command, args, options = {}) {
+  const { extraEnv, timeoutMs = OPEN_TIMEOUT_MS } = options;
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, [...args], {
+      stdio: "ignore",
+      ...extraEnv ? { env: { ...process.env, ...extraEnv } } : {}
+    });
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(
+        new SpawnHangError(`${command} did not exit within ${timeoutMs}ms`)
+      );
+    }, timeoutMs);
+    child.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once("close", () => {
+      clearTimeout(timer);
+      resolve2();
+    });
+  });
+}
+__name(spawnAndIgnoreExitCode, "spawnAndIgnoreExitCode");
+function spawnLongLived(command, args, timeoutMs = OPEN_TIMEOUT_MS) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, [...args], {
+      stdio: "ignore",
+      detached: true
+    });
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(
+        new SpawnHangError(`${command} did not spawn within ${timeoutMs}ms`)
+      );
+    }, timeoutMs);
+    child.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once("spawn", () => {
+      clearTimeout(timer);
+      child.unref();
+      resolve2();
+    });
+  });
+}
+__name(spawnLongLived, "spawnLongLived");
+
 // packages/cli/src/serve/types.ts
 init_esbuild_shims();
 var CAPABILITIES_SCHEMA_VERSION = 1;
@@ -2003,7 +2499,7 @@ import {
   basename,
   dirname,
   isAbsolute,
-  join,
+  join as join3,
   relative,
   resolve
 } from "node:path";
@@ -2081,7 +2577,7 @@ async function revalidateManagedScratchRoot(root) {
 __name(revalidateManagedScratchRoot, "revalidateManagedScratchRoot");
 async function createManagedScratchDirectory(root) {
   await revalidateManagedScratchRoot(root);
-  const created = await mkdtemp(join(root.canonicalRoot, "scratch-"));
+  const created = await mkdtemp(join3(root.canonicalRoot, "scratch-"));
   const canonical = realpathSync.native(created);
   if (!isManagedScratchChild(canonical, root.canonicalRoot)) {
     throw new Error("Managed scratch directory escaped its accepted root");
@@ -3053,6 +3549,7 @@ async function buildDaemonStatusResponse(detail, input) {
       writerIdleTimeoutMs: positiveFiniteOrNull(input.opts.writerIdleTimeoutMs),
       channelIdleTimeoutMs: bridgeSnapshot.limits.channelIdleTimeoutMs,
       sessionIdleTimeoutMs: bridgeSnapshot.limits.sessionIdleTimeoutMs,
+      sessionPromptSettledCloseGraceMs: bridgeSnapshot.limits.sessionPromptSettledCloseGraceMs,
       acpConnectionCap: acpSnapshot?.connectionCap ?? null,
       acpPreAttachMaxFramesPerStream: acpSnapshot !== void 0 ? ACP_PRE_ATTACH_MAX_FRAMES_PER_STREAM : null,
       acpPreAttachMaxFramesPerConnection: acpSnapshot !== void 0 ? ACP_PRE_ATTACH_MAX_FRAMES_PER_CONNECTION : null,
@@ -3917,6 +4414,7 @@ export {
   createBridgeFileSystemAdapter,
   PathMutexRegistry,
   isDeepHealthQuery,
+  installSelfOriginStripMiddleware,
   acpChildExtraArgs,
   CredentialStore,
   singleTokenCredentials,
@@ -3925,17 +4423,27 @@ export {
   listenerIdentityOfSocket,
   denyBrowserOriginCors,
   parseAllowOriginPatterns,
+  findNonLoopbackHttpOrigin,
   MutableOriginAllowlist,
   allowOriginCors,
   hostAllowlist,
   bearerAuth,
-  requestWasAuthenticated,
+  isTrustedLoopbackMode,
+  requestHasOperatorAuthority,
   createMutationGate,
   ClientMcpSenderRegistry,
   createClientMcpServerProvider,
   SERVE_CAPABILITY_REGISTRY,
   getAdvertisedServeFeatures,
   getServeProtocolVersions,
+  NativeDirectoryPickerUnavailableError,
+  isNativeDirectoryPickerAvailable,
+  pickNativeDirectory,
+  LocalPathOpenUnavailableError,
+  isLocalPathOpenAvailable,
+  isLocalTerminalAvailable,
+  openPathLocally,
+  openTerminalLocally,
   CAPABILITIES_SCHEMA_VERSION,
   isManagedScratchChild,
   isScratchRootCompatible,