dsh-auto-open-web 0.1.2

package/lib/win32.js

@@ -0,0 +1,347 @@
+// dsh-auto-open-web — Windows 平台适配器。
+//
+// 本文件集中全部 win32 专属实现(共通逻辑见 index.js):
+//   - 浏览器可执行文件候选(ProgramFiles 布局)
+//   - Job Object(koffi 驱动,DSH 强退也随进程退出)
+//   - 专用实例进程树清理(pid 状态文件 + 进程身份校验 + taskkill,
+//     不使用 PowerShell)
+//   - 进程树终止(taskkill,供测试实例自动清理)
+//   - 原生文件对话框(worker.cjs 子进程 + koffi IFileOpenDialog)
+//   - WebView2 宿主可执行文件解析(host-publish/DshAppWindow.exe)
+//
+// 平台选择由 platform.js 完成;本文件顶层无平台副作用,非 Windows 上
+// 静态 import 也安全,各函数在 process.platform !== 'win32' 时自行降级。
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { instanceStateFile } from './paths.js';
+
+export const isWindows = process.platform === 'win32';
+
+// koffi 在模块求值时预载(ESM 顶层 await):后续所有函数——包括
+// process 'exit' 处理器——都能同步使用,无需异步 import。
+// 加载失败不致命:进程身份校验降级为保守跳过(见 verifyInstancePid)。
+let koffiLib = null;
+let procApi = null;
+try {
+  koffiLib = (await import('koffi')).default;
+  const kernel32 = koffiLib.load('kernel32.dll');
+  const psapi = koffiLib.load('psapi.dll');
+  procApi = {
+    openProcess: kernel32.func('__stdcall', 'OpenProcess', 'void *', ['uint32', 'int', 'uint32']),
+    getImageName: psapi.func('__stdcall', 'GetProcessImageFileNameW', 'uint32', ['void *', 'void *', 'uint32']),
+    getProcessTimes: kernel32.func('__stdcall', 'GetProcessTimes', 'int', ['void *', 'void *', 'void *', 'void *', 'void *']),
+    closeHandle: kernel32.func('__stdcall', 'CloseHandle', 'int', ['void *']),
+    fileTime: koffiLib.struct('DshFileTime', { dwLowDateTime: 'uint32', dwHighDateTime: 'uint32' }),
+  };
+} catch {
+  procApi = null;
+}
+
+const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
+const FILE_TIME_MS = 10000; // 100ns 单位 → 毫秒
+const FILETIME_UNIX_EPOCH_MS = 11644473600000; // 1601-01-01 → 1970-01-01 的毫秒差
+
+// ── 浏览器可执行文件候选(仅 Windows 的安装布局) ──────────────────────────
+
+const BROWSER_EXE_CANDIDATES = [
+  {
+    browser: 'edge',
+    candidates: [
+      join(process.env['ProgramFiles(x86)'] ?? '', 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+      join(process.env.ProgramFiles ?? '', 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+    ],
+  },
+  {
+    browser: 'chrome',
+    candidates: [
+      join(process.env.ProgramFiles ?? '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+      join(process.env['ProgramFiles(x86)'] ?? '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    ],
+  },
+];
+
+/**
+ * 解析浏览器可执行文件(仅 Windows):手动路径(browserPath)优先,
+ * 其次内置候选(Edge → Chrome)。手动路径不存在时记录并跳过。
+ */
+export function resolveBrowserExe(browserPath) {
+  if (process.platform !== 'win32') return null;
+  const p = typeof browserPath === 'string' ? browserPath.trim() : '';
+  if (p !== '') {
+    if (existsSync(p)) return { browser: 'custom', exe: p };
+    console.warn(`[auto-open-web] configured browser path not found, skipping: ${p}`);
+  }
+  for (const entry of BROWSER_EXE_CANDIDATES) {
+    const exe = entry.candidates.find((p) => p !== '' && existsSync(p));
+    if (exe !== undefined) return { browser: entry.browser, exe };
+  }
+  return null;
+}
+
+// ── browser 专用实例的 Job Object(DSH 强退也随进程退出) ──────────────────
+//
+// JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE:当作业的最后一个句柄关闭(即持有它的
+// DSH 进程退出——无论正常退出还是被强杀)时,Windows 内核自动结束作业内
+// 所有进程。子进程自动继承作业成员资格,因此只需把启动的 msedge 进程加入
+// 作业,其整个实例进程树就随 DSH 一起消亡,不依赖 exit 事件。
+const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x2000;
+const JOB_OBJECT_EXTENDED_LIMIT_INFORMATION = 9;
+const PROCESS_SET_QUOTA = 0x0100;
+const PROCESS_TERMINATE = 0x0001;
+
+/** { handle, openProc, closeHandle, assign } | { handle: null }(创建失败时的降级标记)。 */
+let browserJob = null;
+
+// JOBOBJECT_EXTENDED_LIMIT_INFORMATION(x64) 的 koffi 结构定义。koffi 的 struct
+// 名是全局注册的,重复定义同名 struct 会报错,因此只建一次。
+// 布局(实测 sizeof = 144 字节):LimitFlags 位于偏移 16(BasicLimitInformation
+// 内),即本结构第 3 个字段。flat 字段顺序与 Windows 定义一致时偏移自然对齐。
+let jobExtType = null;
+
+export async function ensureBrowserJob() {
+  if (browserJob !== null) return browserJob;
+  try {
+    const koffi = (await import('koffi')).default;
+    const kernel32 = koffi.load('kernel32.dll');
+    const createJob = kernel32.func('__stdcall', 'CreateJobObjectW', 'void *', ['void *', 'void *']);
+    const setInfo = kernel32.func('__stdcall', 'SetInformationJobObject', 'int', ['void *', 'uint32', 'void *', 'uint32']);
+    const assign = kernel32.func('__stdcall', 'AssignProcessToJobObject', 'int', ['void *', 'void *']);
+    const openProc = kernel32.func('__stdcall', 'OpenProcess', 'void *', ['uint32', 'int', 'uint32']);
+    const closeHandle = kernel32.func('__stdcall', 'CloseHandle', 'int', ['void *']);
+    const job = createJob(null, null);
+    if (job === null || job === 0) throw new Error('CreateJobObjectW failed');
+    if (jobExtType === null) {
+      jobExtType = koffi.struct('JobObjectExtendedLimitInformation', {
+        PerProcessUserTimeLimit: 'int64',
+        PerJobUserTimeLimit: 'int64',
+        LimitFlags: 'uint32',
+        MinimumWorkingSetSize: 'int64',
+        MaximumWorkingSetSize: 'int64',
+        ActiveProcessLimit: 'uint32',
+        Affinity: 'int64',
+        PriorityClass: 'uint32',
+        SchedulingClass: 'uint32',
+        IoReadOperationCount: 'int64',
+        IoWriteOperationCount: 'int64',
+        IoOtherOperationCount: 'int64',
+        IoReadTransferCount: 'int64',
+        IoWriteTransferCount: 'int64',
+        IoOtherTransferCount: 'int64',
+        ProcessMemoryLimit: 'int64',
+        JobMemoryLimit: 'int64',
+        PeakProcessMemoryUsed: 'int64',
+        PeakJobMemoryUsed: 'int64',
+      });
+    }
+    // koffi.decode 对结构体是值拷贝:必须用 koffi.encode 写入内存。
+    // 只设置 LimitFlags 一个字段,其余保持零值(不施加其他作业限制)。
+    const mem = koffi.alloc(jobExtType, koffi.sizeof(jobExtType));
+    koffi.encode(mem, jobExtType, { LimitFlags: JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE });
+    if (setInfo(job, JOB_OBJECT_EXTENDED_LIMIT_INFORMATION, mem, koffi.sizeof(jobExtType)) === 0) {
+      closeHandle(job);
+      throw new Error('SetInformationJobObject failed');
+    }
+    browserJob = { handle: job, openProc, closeHandle, assign };
+    console.log('[auto-open-web] browser job object ready (KILL_ON_JOB_CLOSE)');
+    return browserJob;
+  } catch (error) {
+    console.error(`[auto-open-web] job object unavailable: ${error.message}; falling back to exit/pre-launch cleanup`);
+    browserJob = { handle: null };
+    return browserJob;
+  }
+}
+
+/** 把 pid 加入浏览器作业;失败返回 false(不致命,exit/预清理仍兜底)。 */
+export function assignToBrowserJob(job, pid) {
+  if (job === null || job.handle === null) return false;
+  try {
+    const h = job.openProc(PROCESS_SET_QUOTA | PROCESS_TERMINATE, 0, pid);
+    if (h === null || h === 0) return false;
+    try {
+      return job.assign(job.handle, h) !== 0;
+    } finally {
+      job.closeHandle(h);
+    }
+  } catch {
+    return false;
+  }
+}
+
+// ── 专用实例清理与进程树终止 ─────────────────────────────────────────────
+
+/**
+ * 校验 pid 状态文件指向的进程是否仍是我们的专用实例(防 pid 复用误杀):
+ *   - 进程必须存在(不存在 → 'gone');
+ *   - 镜像文件名必须与记录一致(被复用为其他进程 → 'mismatch');
+ *   - 进程创建时间必须早于状态文件写入时间(被复用的新进程必然更晚
+ *     → 'mismatch')。
+ * 返回 'match' | 'gone' | 'mismatch'。koffi 不可用时保守返回 'mismatch'
+ * (不杀,安全优先)。
+ */
+function verifyInstancePid(pid, state) {
+  if (procApi === null) {
+    console.warn('[auto-open-web] process verification unavailable; skipping instance cleanup');
+    return 'mismatch';
+  }
+  const h = procApi.openProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid);
+  if (h === null || h === 0) return 'gone';
+  try {
+    const buf = koffiLib.alloc('uint16', 1024);
+    const len = procApi.getImageName(h, buf, 1024);
+    if (len === 0) return 'gone';
+    const image = koffiLib.decode(buf, 'char16', len);
+    const expected = typeof state.exe === 'string' && state.exe !== '' ? basename(state.exe).toLowerCase() : '';
+    if (expected !== '' && basename(image).toLowerCase() !== expected) return 'mismatch';
+    // 创建时间(100ns FILETIME)→ 毫秒;须早于状态文件写入时间(容差 5 秒)。
+    // 注意:koffi 3.x 无 koffi.offset,用 4 个独立分配的结构指针(alloc 的
+    // count 是元素数,1 = 单个 FILETIME)。
+    const creationFt = koffiLib.alloc(procApi.fileTime, 1);
+    const exitFt = koffiLib.alloc(procApi.fileTime, 1);
+    const kernelFt = koffiLib.alloc(procApi.fileTime, 1);
+    const userFt = koffiLib.alloc(procApi.fileTime, 1);
+    if (procApi.getProcessTimes(h, creationFt, exitFt, kernelFt, userFt) === 0) return 'mismatch';
+    const creation = koffiLib.decode(creationFt, procApi.fileTime);
+    const createdMs =
+      (Number(creation.dwHighDateTime) * 4294967296 + Number(creation.dwLowDateTime)) / FILE_TIME_MS -
+      FILETIME_UNIX_EPOCH_MS;
+    if (typeof state.writtenAt === 'number' && createdMs > state.writtenAt + 5000) return 'mismatch';
+    return 'match';
+  } catch {
+    return 'mismatch';
+  } finally {
+    procApi.closeHandle(h);
+  }
+}
+
+/**
+ * 结束指定浏览器类型的专用实例进程树(仅我们自己的专用实例,不影响正常
+ * 浏览器页面)。基于 pid 状态文件 + 进程身份校验(见 verifyInstancePid),
+ * 不使用 PowerShell。同步执行,可在 process 'exit' 处理器中使用。
+ * 进程已不存在时顺带删除状态文件(下次不再处理)。
+ */
+export function killDedicatedBrowserInstances(browser) {
+  if (process.platform !== 'win32') return;
+  const statePath = instanceStateFile(browser);
+  let state = null;
+  try {
+    state = JSON.parse(readFileSync(statePath, 'utf8'));
+  } catch {
+    return; // 无状态文件/损坏 → 无记录可清理
+  }
+  const pid = state !== null && typeof state === 'object' ? state.pid : 0;
+  if (!Number.isInteger(pid) || pid <= 0) return;
+  const verdict = verifyInstancePid(pid, state);
+  if (verdict === 'gone') {
+    try {
+      rmSync(statePath, { force: true });
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+  if (verdict !== 'match') return; // 校验不过:pid 已被复用或无法确认,不误杀
+  try {
+    spawnSync('taskkill.exe', ['/PID', String(pid), '/T', '/F'], {
+      stdio: 'ignore',
+      windowsHide: true,
+      timeout: 15000,
+    });
+  } catch (error) {
+    console.error(`[auto-open-web] dedicated instance cleanup failed: ${error.message}`);
+  }
+}
+
+/** 结束 pid 的整个进程树(同步,可在定时清理中使用)。 */
+export function killProcessTree(pid) {
+  if (process.platform !== 'win32') {
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+  try {
+    spawnSync('taskkill.exe', ['/PID', String(pid), '/T', '/F'], {
+      stdio: 'ignore',
+      windowsHide: true,
+      timeout: 15000,
+    });
+  } catch {
+    /* ignore */
+  }
+}
+
+// ── 原生文件对话框(仅 Windows) ───────────────────────────────────────────
+
+/**
+ * 弹出原生"打开文件"对话框选择浏览器可执行文件(仅 Windows)。
+ * 实现参考官方工作区目录选择器(@deepseek-ai/dsh-host-directory-picker-native):
+ * 生成子进程(worker.cjs)用 koffi 驱动 IFileOpenDialog(文件模式),
+ * 对话框是子进程的第一个窗口,Windows 自动激活 → 总是出现在浏览器上方。
+ * IPC 协议:{showing} → {done,path|null} | {error,message}。
+ * 返回选中路径,取消/失败返回 null;10 分钟无结果则终止子进程。
+ */
+export function pickBrowserExe() {
+  if (process.platform !== 'win32') return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const workerPath = fileURLToPath(new URL('./worker.cjs', import.meta.url));
+    let child;
+    try {
+      child = spawn(process.execPath, [workerPath], {
+        env: { ...process.env, DSH_DIALOG_TITLE: '选择浏览器可执行文件' },
+        stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
+        windowsHide: true,
+      });
+    } catch (error) {
+      console.error(`[auto-open-web] native picker spawn failed: ${error.message}`);
+      resolve(null);
+      return;
+    }
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+        /* ignore */
+      }
+    }, 10 * 60 * 1000);
+    child.on('message', (message) => {
+      if (message === null || typeof message !== 'object') return;
+      if (message.kind === 'done') {
+        clearTimeout(timer);
+        finish(typeof message.path === 'string' && message.path !== '' ? message.path : null);
+      } else if (message.kind === 'error') {
+        clearTimeout(timer);
+        console.error('[auto-open-web] native picker failed: ' + String(message.message ?? 'unknown error'));
+        finish(null);
+      }
+      /* 'showing' 仅用于中止通道,本实现超时即杀子进程,无需跟踪 */
+    });
+    child.on('error', (error) => {
+      clearTimeout(timer);
+      console.error(`[auto-open-web] native picker process error: ${error.message}`);
+      finish(null);
+    });
+    child.on('exit', () => {
+      clearTimeout(timer);
+      finish(null);
+    });
+  });
+}
+
+// ── WebView2 宿主可执行文件(仅 Windows) ──────────────────────────────────
+
+/** 解析随包分发的宿主可执行文件(仅 Windows)。 */
+export function resolveHostExe() {
+  if (process.platform !== 'win32') return null;
+  const exe = fileURLToPath(new URL('../host-publish/DshAppWindow.exe', import.meta.url));
+  return existsSync(exe) ? exe : null;
+}

package/lib/worker.cjs

@@ -0,0 +1,174 @@
+// dsh-auto-open-web — Win32 文件选择对话框子进程。
+// 实现参考官方 @deepseek-ai/dsh-host-directory-picker-native 的 worker.cjs
+// (koffi 驱动 IFileOpenDialog 的 COM 对话),仅两处差异:
+//   1. 选项位:去掉 FOS_PICKFOLDERS,改为文件模式
+//      FOS_FORCEFILESYSTEM(0x40) | FOS_PATHMUSTEXIST(0x800) | FOS_FILEMUSTEXIST(0x1000)
+//      = 0x1840 = 6208;
+//   2. 标题:由环境变量 DSH_DIALOG_TITLE 传入(与官方一致)。
+// 子进程的第一个窗口就是对话框,Windows 会自动激活它(无需前台调用),
+// 因此对话框总是出现在浏览器上方。
+//
+// IPC 协议(与官方一致):{kind:'showing',threadId} → {kind:'done',path|null}
+// 或 {kind:'error',message}。被杀死/退出未报告 → 视为取消。
+//
+// COM vtable 槽位(IUnknown 0-2,IModalWindow 3,IFileDialog 4+)为 Windows Vista
+// 以来冻结的 ABI,常量与官方实现逐字一致。
+
+const SIGDN_FILESYSPATH = -2147123200;
+const COINIT_APARTMENTTHREADED = 2;
+const CLSCTX_INPROC_SERVER = 1;
+const FILE_DIALOG_OPTIONS = 0x1840; // FORCEFILESYSTEM | PATHMUSTEXIST | FILEMUSTEXIST
+const SLOT_RELEASE = 2;
+const SLOT_SHOW = 3;
+const SLOT_SET_OPTIONS = 9;
+const SLOT_SET_TITLE = 17;
+const SLOT_GET_RESULT = 20;
+const SLOT_GET_DISPLAY_NAME = 5;
+const DPI_AWARENESS_CONTEXTS = [-4, -3, -2];
+
+function readUtf16(koffi, address) {
+  const bytes = Buffer.from(koffi.view(address, 32768));
+  let end = 0;
+  while (end + 1 < bytes.length && bytes[end] !== 0) end += 2;
+  return bytes.toString('utf16le', 0, end);
+}
+
+function guidBytes(text) {
+  const match = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(text);
+  const bytes = Buffer.alloc(16);
+  bytes.writeUInt32LE(parseInt(match[1], 16), 0);
+  bytes.writeUInt16LE(parseInt(match[2], 16), 4);
+  bytes.writeUInt16LE(parseInt(match[3], 16), 6);
+  Buffer.from(match[4] + match[5], 'hex').copy(bytes, 8);
+  return bytes;
+}
+
+const CLSID_FILE_OPEN_DIALOG = guidBytes('dc1c5a9c-e88a-4dde-a5a1-60f82a20aef7');
+const IID_IFILE_OPEN_DIALOG = guidBytes('d57c7288-d4ad-4768-be02-9d969532d960');
+
+async function loadWin32DialogBindings() {
+  const koffi = (await import('koffi')).default;
+  const ole32 = koffi.load('ole32.dll');
+  const user32 = koffi.load('user32.dll');
+  const kernel32 = koffi.load('kernel32.dll');
+  const pointerSize = koffi.sizeof('void *');
+  const coInitializeEx = ole32.func('__stdcall', 'CoInitializeEx', 'int32', ['void *', 'uint32']);
+  const coUninitialize = ole32.func('__stdcall', 'CoUninitialize', 'void', []);
+  const coCreateInstance = ole32.func('__stdcall', 'CoCreateInstance', 'int32', [
+    'void *', 'void *', 'uint32', 'void *', 'void *',
+  ]);
+  const coTaskMemFree = ole32.func('__stdcall', 'CoTaskMemFree', 'void', ['void *']);
+  const getCurrentThreadId = kernel32.func('__stdcall', 'GetCurrentThreadId', 'uint32', []);
+  const protoShow = koffi.proto('int32 __stdcall DshDialogShow(void *self, void *owner)');
+  const protoSetOptions = koffi.proto('int32 __stdcall DshDialogSetOptions(void *self, uint32 options)');
+  const protoSetTitle = koffi.proto('int32 __stdcall DshDialogSetTitle(void *self, str16 title)');
+  const protoGetResult = koffi.proto('int32 __stdcall DshDialogGetResult(void *self, _Out_ void **item)');
+  const protoGetDisplayName = koffi.proto('int32 __stdcall DshItemGetDisplayName(void *self, int32 form, _Out_ void **name)');
+  const protoRelease = koffi.proto('uint32 __stdcall DshComRelease(void *self)');
+  const method = (self, slot, proto) => {
+    const vtable = koffi.decode(self, 'void *');
+    const fn = koffi.decode(vtable, slot * pointerSize, 'void *');
+    return (...args) => koffi.call(fn, proto, self, ...args);
+  };
+  return {
+    setThreadDpiAwareness: () => {
+      let setContext;
+      try {
+        setContext = user32.func('__stdcall', 'SetThreadDpiAwarenessContext', 'void *', ['intptr']);
+      } catch {
+        return;
+      }
+      for (const context of DPI_AWARENESS_CONTEXTS) if (setContext(context) !== null) return;
+    },
+    coInitializeSta: () => coInitializeEx(null, COINIT_APARTMENTTHREADED),
+    coUninitialize: () => {
+      coUninitialize();
+    },
+    currentThreadId: () => getCurrentThreadId(),
+    createFileDialog: () => {
+      const out = Buffer.alloc(pointerSize);
+      const created = coCreateInstance(CLSID_FILE_OPEN_DIALOG, null, CLSCTX_INPROC_SERVER, IID_IFILE_OPEN_DIALOG, out);
+      if (created < 0) throw new Error(`CoCreateInstance(FileOpenDialog) failed: HRESULT 0x${(created >>> 0).toString(16)}`);
+      const dialog = koffi.decode(out, 'void *');
+      return {
+        setOptions: (options) => method(dialog, SLOT_SET_OPTIONS, protoSetOptions)(options),
+        setTitle: (title) => method(dialog, SLOT_SET_TITLE, protoSetTitle)(title),
+        show: () => method(dialog, SLOT_SHOW, protoShow)(null),
+        resultPath: () => {
+          const itemOut = [null];
+          const gotItem = method(dialog, SLOT_GET_RESULT, protoGetResult)(itemOut);
+          if (gotItem < 0) return { hr: gotItem };
+          const item = itemOut[0];
+          try {
+            const nameOut = [null];
+            const gotName = method(item, SLOT_GET_DISPLAY_NAME, protoGetDisplayName)(SIGDN_FILESYSPATH, nameOut);
+            if (gotName < 0) return { hr: gotName };
+            const path = readUtf16(koffi, nameOut[0]);
+            coTaskMemFree(nameOut[0]);
+            return { hr: gotName, path };
+          } finally {
+            method(item, SLOT_RELEASE, protoRelease)();
+          }
+        },
+        release: () => {
+          method(dialog, SLOT_RELEASE, protoRelease)();
+        },
+      };
+    },
+  };
+}
+
+function check(hr, what) {
+  if (hr < 0) throw new Error(`${what} failed: HRESULT 0x${(hr >>> 0).toString(16)}`);
+  return hr;
+}
+
+/** 一次模态文件选择对话:DPI 感知、STA 初始化、创建对话框、Show、取结果。 */
+function runFileDialog(bindings, title, onShowing) {
+  bindings.setThreadDpiAwareness();
+  check(bindings.coInitializeSta(), 'CoInitializeEx');
+  try {
+    const dialog = bindings.createFileDialog();
+    try {
+      check(dialog.setOptions(FILE_DIALOG_OPTIONS), 'SetOptions');
+      check(dialog.setTitle(title), 'SetTitle');
+      onShowing(bindings.currentThreadId());
+      const shown = dialog.show();
+      if (shown === -2147023673) return null; // HRESULT_FROM_WIN32(ERROR_CANCELLED)
+      check(shown, 'Show');
+      const result = dialog.resultPath();
+      check(result.hr, 'GetResult');
+      return result.path;
+    } finally {
+      dialog.release();
+    }
+  } finally {
+    bindings.coUninitialize();
+  }
+}
+
+const title = process.env.DSH_DIALOG_TITLE ?? '';
+if (title === '') throw new Error('dsh-auto-open-web worker: DSH_DIALOG_TITLE is required');
+if (process.send === undefined) throw new Error('dsh-auto-open-web worker must run as a child process with an IPC channel');
+const send = process.send.bind(process);
+const post = (message) => {
+  send(message, () => {
+    if (process.connected) process.disconnect();
+  });
+};
+process.on('disconnect', () => process.exit(0));
+(async () => {
+  try {
+    post({
+      kind: 'done',
+      path: runFileDialog(await loadWin32DialogBindings(), title, (threadId) => {
+        post({ kind: 'showing', threadId });
+      }),
+    });
+  } catch (error) {
+    post({
+      kind: 'error',
+      message: error instanceof Error ? error.stack ?? error.message : String(error),
+    });
+  }
+})();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "dsh-auto-open-web",
+  "version": "0.1.2",
+  "description": "Open the DSH Web GUI in an app-style WebView2 window on profile start, with a settings card for browser paths",
+  "type": "module",
+  "main": "lib/index.js",
+  "scripts": {
+    "build:host": "dotnet publish host/DshAppWindow.csproj -c Release -o host-publish --nologo",
+    "prepack": "npm run build:host"
+  },
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
+    }
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/worker.cjs",
+    "lib/paths.js",
+    "lib/platform.js",
+    "lib/win32.js",
+    "lib/posix.js",
+    "host-publish",
+    "cordis.patch.yml",
+    "README.md",
+    "README.en.md"
+  ],
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "koffi": "^3.1.4"
+  },
+  "license": "MIT"
+}