@youtyan/code-viewer 0.11.1 → 0.11.2

package/dist/code-viewer.js

@@ -1173,7 +1173,7 @@ function runBytesSync(args, cwd2, options = {}) {
 }
 function runBytesAsync(args, cwd2, options = {}) {
   const maxBuffer = options.maxBuffer ?? 64 * 1024 * 1024;
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const proc = spawn(args[0], args.slice(1), {
       cwd: cwd2,
       stdio: [options.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
@@ -1214,7 +1214,7 @@ function runBytesAsync(args, cwd2, options = {}) {
       } else {
         stderr = appendProcessError(stderr, processError);
       }
-      resolve3({
+      resolve4({
         code,
         stdout: concatBytes(stdoutChunks),
         stderr
@@ -1260,41 +1260,28 @@ function concatBytes(chunks) {
   }
   return out;
 }
-function spawnDetached(args) {
-  const child = spawn(args[0], args.slice(1), {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.on("error", (err) => {
-    console.warn(
-      "[code-viewer] failed to start detached command:",
-      err.message
-    );
-  });
-  child.unref();
-}
 function spawnStream(args, cwd2) {
   const proc = spawn(args[0], args.slice(1), {
     cwd: cwd2,
     stdio: ["ignore", "pipe", "ignore"]
   });
-  let errorCode = 0;
+  let errorCode2 = 0;
   proc.on("error", () => {
-    errorCode = 1;
+    errorCode2 = 1;
   });
   return {
     stream: Readable.toWeb(
       proc.stdout
     ),
-    exited: new Promise((resolve3) => {
+    exited: new Promise((resolve4) => {
       let settled = false;
       const done = (code) => {
         if (settled) return;
         settled = true;
-        resolve3(code);
+        resolve4(code);
       };
       proc.on("error", () => done(1));
-      proc.on("close", (code) => done(errorCode || (code ?? 1)));
+      proc.on("close", (code) => done(errorCode2 || (code ?? 1)));
     }),
     kill: (signal) => proc.kill(signal)
   };
@@ -1350,7 +1337,7 @@ function startServer(options) {
       res.end("internal server error");
     }
   });
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     server2.once("error", reject);
     server2.listen(options.port, options.hostname, () => {
       server2.off("error", reject);
@@ -1359,7 +1346,7 @@ function startServer(options) {
       });
       const address = server2.address();
       const port = typeof address === "object" && address ? address.port : options.port;
-      resolve3({
+      resolve4({
         port,
         close: () => new Promise((resolveClose, rejectClose) => {
           let settled = false;
@@ -1418,7 +1405,7 @@ async function writeWebResponse(res, response) {
     res.end();
     return;
   }
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve4, reject) => {
     const body = Readable.fromWeb(
       response.body
     );
@@ -1435,12 +1422,12 @@ async function writeWebResponse(res, response) {
         reject(error);
       })
     );
-    res.on("finish", () => settle(resolve3));
+    res.on("finish", () => settle(resolve4));
     res.on(
       "close",
       () => settle(() => {
         body.destroy();
-        resolve3();
+        resolve4();
       })
     );
     body.pipe(res);
@@ -2444,7 +2431,7 @@ async function worktreeFilesystemEntriesAsync(cwd2, path, recursive, omitDirName
   const yieldIfNeeded = async () => {
     visitedDirs++;
     if (visitedDirs % 25 === 0) {
-      await new Promise((resolve3) => setTimeout(resolve3, 0));
+      await new Promise((resolve4) => setTimeout(resolve4, 0));
     }
   };
   const walk = async (dir, prefix, depth) => {
@@ -7925,7 +7912,7 @@ function searchPollIntervalMs() {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function cancelSearchJobBestEffort(serverUrl, jobId) {
   try {
@@ -8707,8 +8694,8 @@ function computeFuzzyMatch(query, path) {
   const first = indices[0];
   score -= Math.min(first, 40);
   if (indices[0] >= baseStart) score += 20;
-  const basename5 = lowerPath.slice(baseStart);
-  const tier = pathMatchTier(q, lowerPath, basename5);
+  const basename6 = lowerPath.slice(baseStart);
+  const tier = pathMatchTier(q, lowerPath, basename6);
   const contiguousRange = contiguousPathRange(q, lowerPath, baseStart);
   return {
     score,
@@ -8860,8 +8847,8 @@ function createGlobPathMatcher(query) {
   const suffix = query.replace(/^\*+/, "").toLowerCase();
   return (path) => {
     const baseStart = basenameStart(path);
-    const basename5 = path.slice(baseStart);
-    if (!regex.test(path) && (query.includes("/") || !regex.test(basename5)))
+    const basename6 = path.slice(baseStart);
+    if (!regex.test(path) && (query.includes("/") || !regex.test(basename6)))
       return null;
     const ranges = [];
     const lowerPath = path.toLowerCase();
@@ -10840,7 +10827,7 @@ function send(message) {
 `);
 }
 function readConfigLine() {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let buffer = "";
     const stdin = process.stdin;
     stdin.setEncoding("utf8");
@@ -10850,7 +10837,7 @@ function readConfigLine() {
       if (newline === -1) return;
       stdin.off("data", onData);
       stdin.off("end", onEnd);
-      resolve3(buffer.slice(0, newline));
+      resolve4(buffer.slice(0, newline));
     };
     const onEnd = () => {
       stdin.off("data", onData);
@@ -10861,12 +10848,12 @@ function readConfigLine() {
   });
 }
 function hashFile(path) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const hash = createHash2("sha256");
     const stream = createReadStream2(path);
     stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => resolve3(hash.digest("hex")));
-    stream.on("error", () => resolve3("unreadable"));
+    stream.on("end", () => resolve4(hash.digest("hex")));
+    stream.on("error", () => resolve4("unreadable"));
   });
 }
 function parsePorcelainV2(raw) {
@@ -11391,7 +11378,7 @@ function waitForAbortableResource(promise, signal, dispose, message = "operation
     void promise.then(disposeSafely, () => void 0);
     return Promise.reject(abortError(message));
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let aborted = false;
     const onAbort = () => {
       aborted = true;
@@ -11406,7 +11393,7 @@ function waitForAbortableResource(promise, signal, dispose, message = "operation
           disposeSafely(resource);
           return;
         }
-        resolve3(resource);
+        resolve4(resource);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -11436,7 +11423,7 @@ function appendMessage(buffer, message) {
 function spawnCollectAsync(opts) {
   throwIfAborted(opts.signal, opts.abortMessage);
   const killSignal = opts.killSignal ?? "SIGTERM";
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const child = spawn2(opts.command, opts.args, {
       cwd: opts.cwd,
       env: opts.env,
@@ -11453,7 +11440,7 @@ function spawnCollectAsync(opts) {
       opts.signal?.removeEventListener("abort", abort);
       let stderr = Buffer.concat(stderrChunks);
       if (fallbackStderr) stderr = appendMessage(stderr, fallbackStderr);
-      resolve3({
+      resolve4({
         stdout: Buffer.concat(stdoutChunks),
         stderr,
         code
@@ -15062,7 +15049,7 @@ function guardedS3Transport(signal, operation, deadline) {
     controller.abort(err);
     reject(err);
   };
-  const guarded = new Promise((resolve3, reject) => {
+  const guarded = new Promise((resolve4, reject) => {
     const onParentAbort = () => abort(new S3HttpError(503, "S3 HTTP transport aborted"), reject);
     if (signal) {
       signal.addEventListener("abort", onParentAbort, { once: true });
@@ -15076,7 +15063,7 @@ function guardedS3Transport(signal, operation, deadline) {
       (value) => {
         if (settled) return;
         settled = true;
-        resolve3(value);
+        resolve4(value);
       },
       (err) => {
         if (settled) return;
@@ -18180,7 +18167,7 @@ function guardedDynamoDbTransport(signal, operation, deadline) {
     controller.abort(err);
     reject(err);
   };
-  const guarded = new Promise((resolve3, reject) => {
+  const guarded = new Promise((resolve4, reject) => {
     const onParentAbort = () => abort(
       new DynamoDbHttpError(503, "DynamoDB HTTP transport aborted"),
       reject
@@ -18197,7 +18184,7 @@ function guardedDynamoDbTransport(signal, operation, deadline) {
       (value) => {
         if (settled) return;
         settled = true;
-        resolve3(value);
+        resolve4(value);
       },
       (err) => {
         if (settled) return;
@@ -19345,7 +19332,7 @@ async function parseBoundedJsonBody(req, maxBytes, tooLargeMessage) {
 function waitForCallerAbort(promise, signal, message) {
   if (!signal) return promise;
   if (signal.aborted) return Promise.reject(abortError(message));
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let settled = false;
     const cleanup = () => signal.removeEventListener("abort", onAbort);
     const onAbort = () => {
@@ -19360,7 +19347,7 @@ function waitForCallerAbort(promise, signal, message) {
         if (settled) return;
         settled = true;
         cleanup();
-        resolve3(value);
+        resolve4(value);
       },
       (err) => {
         if (settled) return;
@@ -23248,8 +23235,8 @@ async function handleSnapshotCreate(cwd2, req, sendSse2, omitDirNames) {
   let activeSnapshotId;
   let resolveIdAck;
   let rejectIdAck;
-  const idAck = new Promise((resolve3, reject) => {
-    resolveIdAck = resolve3;
+  const idAck = new Promise((resolve4, reject) => {
+    resolveIdAck = resolve4;
     rejectIdAck = reject;
   });
   (async () => {
@@ -24361,8 +24348,8 @@ function writeToShellWhenReady(id, data) {
   const entry = sessions.get(id);
   if (!entry || entry.meta.exited) return Promise.resolve({ status: "gone" });
   if (entry.ready) return Promise.resolve(writeToShellEntry(entry, data));
-  return new Promise((resolve3) => {
-    entry.queued.push({ data, resolve: resolve3 });
+  return new Promise((resolve4) => {
+    entry.queued.push({ data, resolve: resolve4 });
   });
 }
 function writeToShell(id, data) {
@@ -24391,14 +24378,14 @@ function resizeShell(id, cols, rows) {
 }
 function waitForShellExit(entry) {
   if (entry.meta.exited) return Promise.resolve(true);
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let settled = false;
     const finish = (exited) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer2);
       entry.exitListeners.delete(onExit);
-      resolve3(exited);
+      resolve4(exited);
     };
     const onExit = () => finish(true);
     entry.exitListeners.add(onExit);
@@ -25582,10 +25569,10 @@ async function runProbeWithTimeout(probe, file, cwd2, timeoutMs, parentSignal) {
       timedOut: false
     })
   );
-  const timeoutPromise = new Promise((resolve3) => {
+  const timeoutPromise = new Promise((resolve4) => {
     timer2 = setTimeout(() => {
       controller.abort();
-      resolve3({
+      resolve4({
         kind: "fail",
         reason: `timed out after ${timeoutMs}ms`,
         timedOut: true
@@ -26018,6 +26005,102 @@ var init_dev_assets = __esm({
   }
 });
 
+// web-src/server/file-upload.ts
+import {
+  closeSync as closeSync2,
+  constants as constants3,
+  openSync as openSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+function errorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return void 0;
+}
+function withErrorCode(error, code) {
+  return code === void 0 ? error : Object.assign(error, { code });
+}
+function writeAndClose(upload, fd, bytes, fileSystem) {
+  let writeError;
+  try {
+    fileSystem.write(fd, bytes);
+  } catch (error) {
+    writeError = error;
+  }
+  try {
+    fileSystem.close(fd);
+  } catch (closeError) {
+    if (writeError !== void 0) {
+      throw withErrorCode(
+        errorWithCauses(`failed to write and close ${upload.target}`, [
+          writeError,
+          closeError
+        ]),
+        errorCode(writeError)
+      );
+    }
+    throw errorWithCause(`failed to close ${upload.target}`, closeError);
+  }
+  if (writeError !== void 0) throw writeError;
+}
+async function writeUploadedFiles(uploads, fileSystem = NODE_FILE_SYSTEM) {
+  const created = [];
+  try {
+    for (const upload of uploads) {
+      const bytes = new Uint8Array(await upload.file.arrayBuffer());
+      const fd = fileSystem.open(upload.target);
+      created.push(upload.target);
+      writeAndClose(upload, fd, bytes, fileSystem);
+    }
+  } catch (error) {
+    const cleanupErrors = [];
+    for (const path of created) {
+      try {
+        fileSystem.remove(path);
+      } catch (cleanupError) {
+        cleanupErrors.push(
+          errorWithCause(
+            `failed to remove partial upload ${path}`,
+            cleanupError
+          )
+        );
+      }
+    }
+    const code = errorCode(error);
+    if (cleanupErrors.length > 0) {
+      throw withErrorCode(
+        errorWithCauses(
+          "failed to write uploaded files and clean up partial files",
+          [error, ...cleanupErrors]
+        ),
+        code
+      );
+    }
+    throw withErrorCode(
+      errorWithCause("failed to write uploaded files", error),
+      code
+    );
+  }
+}
+var NODE_FILE_SYSTEM;
+var init_file_upload = __esm({
+  "web-src/server/file-upload.ts"() {
+    init_error_detail();
+    NODE_FILE_SYSTEM = {
+      open: (path) => openSync2(
+        path,
+        constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | (constants3.O_NOFOLLOW || 0),
+        420
+      ),
+      write: (fd, bytes) => writeFileSync2(fd, bytes),
+      close: (fd) => closeSync2(fd),
+      remove: (path) => unlinkSync2(path)
+    };
+  }
+});
+
 // web-src/server/journal.ts
 import { join as join18 } from "node:path";
 function dailyJournalFilePath(root) {
@@ -28960,6 +29043,367 @@ var init_mcp = __esm({
   }
 });
 
+// web-src/server/os-platform.ts
+function isWsl(platform, release) {
+  return platform === "linux" && /wsl/i.test(release);
+}
+var init_os_platform = __esm({
+  "web-src/server/os-platform.ts"() {
+  }
+});
+
+// web-src/server/os-opener.ts
+import { release as osRelease } from "node:os";
+function directoryCommands(path, platform) {
+  if (platform === "darwin") {
+    return [{ args: ["open", "--", path], cwd: path }];
+  }
+  if (platform === "win32") {
+    return [{ args: ["explorer.exe", path], cwd: path }];
+  }
+  return [
+    { args: ["xdg-open", path], cwd: path },
+    { args: ["gio", "open", path], cwd: path }
+  ];
+}
+function urlCommands(url, cwd2, platform) {
+  if (platform === "darwin") {
+    return [{ args: ["open", url], cwd: cwd2 }];
+  }
+  if (platform === "win32") {
+    return [{ args: ["cmd.exe", "/c", "start", "", url], cwd: cwd2 }];
+  }
+  return [
+    { args: ["xdg-open", url], cwd: cwd2 },
+    { args: ["gio", "open", url], cwd: cwd2 }
+  ];
+}
+function commandResultError(command, result) {
+  return Object.assign(
+    new Error(
+      result.code === 0 ? `${command.args[0]} wrote to stderr` : `${command.args[0]} exited with ${result.code}`
+    ),
+    {
+      command: command.args,
+      cwd: command.cwd,
+      result
+    }
+  );
+}
+async function executeOpenCommand(command) {
+  try {
+    return await runAsync(command.args, command.cwd, {
+      timeout: OPEN_TIMEOUT_MS
+    });
+  } catch (error) {
+    throw commandExecutionError(command, error);
+  }
+}
+function commandSucceeded(result) {
+  return result.code === 0 && result.stderr.trim() === "";
+}
+function commandExecutionError(command, cause) {
+  return Object.assign(
+    errorWithCause(`failed to execute ${command.args[0]}`, cause),
+    {
+      command: command.args,
+      cwd: command.cwd
+    }
+  );
+}
+async function runOpenCommands(commands, operation, errors = []) {
+  for (const command of commands) {
+    try {
+      const result = await executeOpenCommand(command);
+      if (commandSucceeded(result)) return;
+      errors.push(commandResultError(command, result));
+    } catch (error) {
+      errors.push(
+        error instanceof Error ? error : commandExecutionError(command, error)
+      );
+    }
+  }
+  throw errorWithCauses(`failed to ${operation}`, errors);
+}
+async function commandOutput(command) {
+  const result = await executeOpenCommand(command);
+  if (!commandSucceeded(result)) throw commandResultError(command, result);
+  const output = result.stdout.trim();
+  if (!output) {
+    throw Object.assign(new Error(`${command.args[0]} returned no path`), {
+      command: command.args,
+      cwd: command.cwd,
+      result
+    });
+  }
+  return output;
+}
+async function wslWindowsCommandCwd(cwd2) {
+  return commandOutput({ args: ["wslpath", "-u", "C:\\"], cwd: cwd2 });
+}
+async function openWslDirectory(path) {
+  const errors = [];
+  try {
+    const windowsPath = await commandOutput({
+      args: ["wslpath", "-w", path],
+      cwd: path
+    });
+    const windowsCwd = await wslWindowsCommandCwd(path);
+    const command = {
+      args: ["cmd.exe", "/c", "start", "", windowsPath],
+      cwd: windowsCwd
+    };
+    const result = await executeOpenCommand(command);
+    if (commandSucceeded(result)) return;
+    errors.push(commandResultError(command, result));
+  } catch (error) {
+    errors.push(
+      error instanceof Error ? error : errorWithCause("failed to open directory through WSL", error)
+    );
+  }
+  return runOpenCommands(
+    [
+      { args: ["gio", "open", path], cwd: path },
+      { args: ["xdg-open", path], cwd: path }
+    ],
+    "open directory in OS",
+    errors
+  );
+}
+async function openWslUrl(url, cwd2) {
+  const errors = [];
+  try {
+    const windowsCwd = await wslWindowsCommandCwd(cwd2);
+    const command = {
+      args: ["cmd.exe", "/c", "start", "", url],
+      cwd: windowsCwd
+    };
+    const result = await executeOpenCommand(command);
+    if (commandSucceeded(result)) return;
+    errors.push(commandResultError(command, result));
+  } catch (error) {
+    errors.push(
+      error instanceof Error ? error : errorWithCause("failed to open URL through WSL", error)
+    );
+  }
+  return runOpenCommands(
+    [
+      { args: ["gio", "open", url], cwd: cwd2 },
+      { args: ["xdg-open", url], cwd: cwd2 }
+    ],
+    "open URL in OS",
+    errors
+  );
+}
+function openDirectoryInOs(path, platform = process.platform, release = osRelease()) {
+  if (isWsl(platform, release)) return openWslDirectory(path);
+  return runOpenCommands(
+    directoryCommands(path, platform),
+    "open directory in OS"
+  );
+}
+function openUrlInOs(url, cwd2, platform = process.platform, release = osRelease()) {
+  if (isWsl(platform, release)) return openWslUrl(url, cwd2);
+  return runOpenCommands(urlCommands(url, cwd2, platform), "open URL in OS");
+}
+var OPEN_TIMEOUT_MS;
+var init_os_opener = __esm({
+  "web-src/server/os-opener.ts"() {
+    init_error_detail();
+    init_os_platform();
+    init_runtime();
+    OPEN_TIMEOUT_MS = 15e3;
+  }
+});
+
+// web-src/server/os-trash.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { existsSync as existsSync8, lstatSync as lstatSync5, mkdirSync as mkdirSync4, renameSync } from "node:fs";
+import { homedir as homedir3, release as osRelease2 } from "node:os";
+import { basename as basename3, dirname as dirname6, join as join21, resolve as resolve2 } from "node:path";
+function windowsTrashScript(path) {
+  const quotedPath = path.replace(/'/g, "''");
+  return [
+    "$ErrorActionPreference = 'Stop';",
+    `$path = '${quotedPath}';`,
+    "Add-Type -TypeDefinition @'",
+    "using System;",
+    "using System.Runtime.InteropServices;",
+    "public static class CodeViewerRecycleBin {",
+    "  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]",
+    "  public struct SHFILEOPSTRUCT {",
+    "    public IntPtr hwnd;",
+    "    public uint wFunc;",
+    "    public string pFrom;",
+    "    public string pTo;",
+    "    public ushort fFlags;",
+    "    [MarshalAs(UnmanagedType.Bool)] public bool fAnyOperationsAborted;",
+    "    public IntPtr hNameMappings;",
+    "    public string lpszProgressTitle;",
+    "  }",
+    '  [DllImport("shell32.dll", CharSet = CharSet.Unicode)]',
+    "  private static extern int SHFileOperationW(ref SHFILEOPSTRUCT lpFileOp);",
+    "  public static void MoveToRecycleBin(string path) {",
+    "    const uint FO_DELETE = 0x0003;",
+    "    const ushort FOF_SILENT = 0x0004;",
+    "    const ushort FOF_NOCONFIRMATION = 0x0010;",
+    "    const ushort FOF_ALLOWUNDO = 0x0040;",
+    "    const ushort FOF_NOERRORUI = 0x0400;",
+    "    var op = new SHFILEOPSTRUCT {",
+    "      hwnd = IntPtr.Zero,",
+    "      wFunc = FO_DELETE,",
+    '      pFrom = path + "\\0\\0",',
+    "      pTo = null,",
+    "      fFlags = (ushort)(FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT),",
+    "      fAnyOperationsAborted = false,",
+    "      hNameMappings = IntPtr.Zero,",
+    "      lpszProgressTitle = null",
+    "    };",
+    "    int result = SHFileOperationW(ref op);",
+    '    if (result != 0) throw new InvalidOperationException("SHFileOperationW failed: " + result);',
+    '    if (op.fAnyOperationsAborted) throw new OperationCanceledException("SHFileOperationW aborted");',
+    "  }",
+    "}",
+    "'@;",
+    "[CodeViewerRecycleBin]::MoveToRecycleBin($path);"
+  ].join(" ");
+}
+function windowsRestoreTrashScript(originalPath) {
+  const quotedPath = originalPath.replace(/'/g, "''");
+  return [
+    "$ErrorActionPreference = 'Stop';",
+    `$original = '${quotedPath}';`,
+    "$parent = [System.IO.Path]::GetDirectoryName($original);",
+    "$name = [System.IO.Path]::GetFileName($original);",
+    "$shell = New-Object -ComObject Shell.Application;",
+    "$bin = $shell.Namespace(10);",
+    "$restored = $false;",
+    "foreach ($item in $bin.Items()) {",
+    "  $deletedFrom = $item.ExtendedProperty('System.Recycle.DeletedFrom');",
+    "  if ($item.Name -eq $name -and $deletedFrom -eq $parent) {",
+    "    $item.InvokeVerb('ESTORE');",
+    "    $restored = $true;",
+    "    break;",
+    "  }",
+    "}",
+    "if (-not $restored) { throw 'recycle bin item not found'; }"
+  ].join(" ");
+}
+function commandResultError2(operation, command, cwd2, result) {
+  return Object.assign(new Error(`${operation} failed`), {
+    command,
+    cwd: cwd2,
+    result
+  });
+}
+async function runRequiredCommand(operation, command, cwd2) {
+  let result;
+  try {
+    result = await runAsync(command, cwd2, { timeout: TRASH_TIMEOUT_MS });
+  } catch (cause) {
+    throw Object.assign(errorWithCause(`${operation} failed`, cause), {
+      command,
+      cwd: cwd2
+    });
+  }
+  if (result.code !== 0) {
+    throw commandResultError2(operation, command, cwd2, result);
+  }
+}
+function managedTrashRoot(cwd2) {
+  return join21(cwd2, ".code-viewer", "trash");
+}
+function movePathIntoTrashDirectory(path, trashRoot) {
+  mkdirSync4(trashRoot, { recursive: true });
+  const name = basename3(path) || "trash-item";
+  const trashPath = join21(trashRoot, `${name}-${randomUUID2()}`);
+  if (existsSync8(trashPath)) {
+    throw Object.assign(new Error("trash destination already exists"), {
+      trashPath
+    });
+  }
+  renameSync(path, trashPath);
+  return { trashPath };
+}
+function trashRootForHandle(cwd2, platform, release) {
+  if (platform === "darwin") return join21(homedir3(), ".Trash");
+  if (isWsl(platform, release)) return managedTrashRoot(cwd2);
+  return null;
+}
+function unsupportedTrashError(operation, platform, release) {
+  return Object.assign(new Error(`${operation} unsupported`), {
+    platform,
+    release
+  });
+}
+async function movePathToTrash(path, cwd2, platform = process.platform, release = osRelease2()) {
+  lstatSync5(path);
+  if (platform === "darwin") {
+    return movePathIntoTrashDirectory(path, join21(homedir3(), ".Trash"));
+  }
+  if (isWsl(platform, release)) {
+    return movePathIntoTrashDirectory(path, managedTrashRoot(cwd2));
+  }
+  if (platform === "win32") {
+    await runRequiredCommand(
+      "move path to Recycle Bin",
+      [
+        "powershell.exe",
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        windowsTrashScript(path)
+      ],
+      cwd2
+    );
+    return {};
+  }
+  throw unsupportedTrashError("trash", platform, release);
+}
+async function restorePathFromTrash(originalPath, trashPath, cwd2, platform = process.platform, release = osRelease2()) {
+  if (existsSync8(originalPath)) {
+    throw new Error("restore target exists");
+  }
+  if (trashPath) {
+    const trashRoot = trashRootForHandle(cwd2, platform, release);
+    if (!trashRoot || dirname6(resolve2(trashPath)) !== resolve2(trashRoot)) {
+      throw new Error("invalid trash handle");
+    }
+    if (!existsSync8(trashPath)) throw new Error("trash item not found");
+    mkdirSync4(dirname6(originalPath), { recursive: true });
+    renameSync(trashPath, originalPath);
+    return;
+  }
+  if (platform === "win32") {
+    await runRequiredCommand(
+      "restore path from Recycle Bin",
+      [
+        "powershell.exe",
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        windowsRestoreTrashScript(originalPath)
+      ],
+      cwd2
+    );
+    return;
+  }
+  throw unsupportedTrashError("restore from trash", platform, release);
+}
+var TRASH_TIMEOUT_MS;
+var init_os_trash = __esm({
+  "web-src/server/os-trash.ts"() {
+    init_error_detail();
+    init_os_platform();
+    init_runtime();
+    TRASH_TIMEOUT_MS = 6e4;
+  }
+});
+
 // web-src/server/request-origin.ts
 function requestAllowed(req) {
   const host = req.headers.get("host") || "";
@@ -28984,12 +29428,12 @@ var init_request_origin = __esm({
 
 // web-src/server/watch-supervisor.ts
 import { spawn as spawn3 } from "node:child_process";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function watchChildCommand() {
   const entry = process.argv[1] ?? "";
   const isTypeScriptEntry = entry.endsWith(".ts");
-  const script = isTypeScriptEntry ? join21(fileURLToPath3(new URL(".", import.meta.url)), "cli.ts") : entry;
+  const script = isTypeScriptEntry ? join22(fileURLToPath3(new URL(".", import.meta.url)), "cli.ts") : entry;
   const loaderArgs = isTypeScriptEntry ? process.execArgv : [];
   return [process.argv[0], ...loaderArgs, script, "watch-child"];
 }
@@ -29766,14 +30210,14 @@ var init_terminal_images = __esm({
 
 // web-src/server/terminal/images.ts
 import { realpathSync as realpathSync7, statSync as statSync7 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { basename as basename3, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename4, isAbsolute as isAbsolute2, resolve as resolve3 } from "node:path";
 function resolveTerminalImage(cwd2, candidate) {
   if (typeof candidate !== "string" || candidate === "") return null;
   if (candidate.includes("\0")) return null;
   if (!terminalImageExtension(candidate)) return null;
-  const expanded = candidate.startsWith("~/") ? resolve2(homedir3(), candidate.slice(2)) : candidate;
-  const full = isAbsolute2(expanded) ? expanded : resolve2(cwd2, expanded);
+  const expanded = candidate.startsWith("~/") ? resolve3(homedir4(), candidate.slice(2)) : candidate;
+  const full = isAbsolute2(expanded) ? expanded : resolve3(cwd2, expanded);
   try {
     const real = realpathSync7(full);
     const stat3 = statSync7(real);
@@ -29798,7 +30242,7 @@ function resolveTerminalImages(cwd2, candidates) {
       path: image.path,
       // 画面で探すのは、渡された綴りそのもの。実体のパスとは違うことがある。
       candidate,
-      name: basename3(image.path),
+      name: basename4(image.path),
       url: terminalImageUrl(image.path)
     });
   }
@@ -29815,7 +30259,7 @@ var init_images = __esm({
 
 // web-src/server/terminal/paste.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 async function savePastedImage(cwd2, mime, base64) {
   const extension = pasteImageExtension(mime);
   if (!extension) {
@@ -29840,8 +30284,8 @@ async function savePastedImage(cwd2, mime, base64) {
     return { status: "invalid", message: "image too large" };
   }
   const name = `${makeTimedId("paste")}.${extension}`;
-  const dir = join22(cwd2, PASTE_DIR);
-  const path = join22(dir, name);
+  const dir = join23(cwd2, PASTE_DIR);
+  const path = join23(dir, name);
   try {
     await mkdir2(dir, { recursive: true });
     await writeFile2(path, bytes);
@@ -29858,7 +30302,7 @@ var init_paste = __esm({
   "web-src/server/terminal/paste.ts"() {
     init_id();
     init_terminal_paste();
-    PASTE_DIR = join22(".code-viewer", "pasted");
+    PASTE_DIR = join23(".code-viewer", "pasted");
   }
 });
 
@@ -30261,22 +30705,14 @@ var init_activity = __esm({
 // web-src/server/preview.ts
 var preview_exports = {};
 import {
-  closeSync as closeSync2,
-  constants as constants3,
-  existsSync as existsSync8,
-  lstatSync as lstatSync5,
-  mkdirSync as mkdirSync4,
-  openSync as openSync2,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync5,
   readFileSync as readFileSync8,
   realpathSync as realpathSync8,
-  renameSync,
   statSync as statSync8,
-  unlinkSync as unlinkSync2,
-  watch,
-  writeFileSync as writeFileSync2
+  watch
 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { basename as basename4, dirname as dirname6, extname as extname2, join as join23, relative as relative8 } from "node:path";
+import { basename as basename5, dirname as dirname7, extname as extname2, join as join24, relative as relative8 } from "node:path";
 function parseCli() {
   const rest = [];
   for (let i = 2; i < process.argv.length; i++) {
@@ -30400,7 +30836,7 @@ Examples:
 }
 function warnIfLegacyConfigPresent() {
   try {
-    if (existsSync8(join23(cwd, ".code-viewer.json"))) {
+    if (existsSync9(join24(cwd, ".code-viewer.json"))) {
       console.warn(
         "[code-viewer] .code-viewer.json is no longer used; configure scope and upload from Viewer Settings instead. The file can be safely removed."
       );
@@ -30507,8 +30943,8 @@ function staticFile(pathname) {
   }
   const spec = map[pathname];
   if (!spec) return null;
-  const full = join23(WEB_ROOT, spec[0]);
-  if (!existsSync8(full)) return text("not found", 404);
+  const full = join24(WEB_ROOT, spec[0]);
+  if (!existsSync9(full)) return text("not found", 404);
   return new Response(readFileSync8(full), {
     headers: { "Content-Type": spec[1], "Cache-Control": "no-store" }
   });
@@ -30602,7 +31038,7 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
       files: [],
       totals: { files: 0, additions: 0, deletions: 0 },
       range: "worktree .. worktree",
-      project: basename4(cwd),
+      project: basename5(cwd),
       branch: await currentBranchMetadata(),
       generation: responseGeneration
     };
@@ -30645,7 +31081,7 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
     files: meta,
     totals,
     range: label || "HEAD",
-    project: basename4(cwd),
+    project: basename5(cwd),
     branch: await currentBranchMetadata(),
     generation: responseGeneration,
     ...metaResult.error ? { error: metaResult.error } : {}
@@ -30766,7 +31202,7 @@ function safeWorktreePath2(path) {
   return safeWorktreePath(currentSearchEnv(), path);
 }
 function worktreePath(path) {
-  return join23(cwd, path);
+  return join24(cwd, path);
 }
 function safeOpenWorktreePath(path) {
   if (path === "") {
@@ -30781,7 +31217,7 @@ function safeOpenWorktreePath(path) {
   return safeWorktreePath2(path);
 }
 function parentRepoPath(path) {
-  const parent = dirname6(path);
+  const parent = dirname7(path);
   return parent === "." ? "" : parent;
 }
 function isoDate(ms) {
@@ -30930,7 +31366,7 @@ async function handleTree(url) {
   return json2({
     ref: target,
     path,
-    project: basename4(cwd),
+    project: basename5(cwd),
     branch: await currentBranchMetadata(),
     entries: recursive ? entries.map(withStatus) : [
       ...await Promise.all(
@@ -30946,7 +31382,7 @@ async function handleTree(url) {
 }
 async function handleSettings() {
   return json2({
-    project: basename4(cwd),
+    project: basename5(cwd),
     branch: await currentBranchMetadata(),
     repo_web_url: cwdHasGitRepository ? await remoteWebUrlAsync(cwd) : null,
     scope: {
@@ -31103,7 +31539,7 @@ async function handleLog(url) {
 }
 function blamePathKey(p) {
   try {
-    const st = statSync8(join23(cwd, p));
+    const st = statSync8(join24(cwd, p));
     return `${st.mtimeMs}:${st.size}`;
   } catch {
     return "missing";
@@ -31591,9 +32027,6 @@ function safeUploadFileName(name) {
   if (!SAFE_UPLOAD_EXTENSIONS.has(extname2(trimmed).toLowerCase())) return null;
   return trimmed;
 }
-function uploadOpenFlags() {
-  return constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | (constants3.O_NOFOLLOW || 0);
-}
 async function handleUploadFiles(req) {
   if (!uploadEnabled) return text("upload disabled by viewer settings", 403);
   if (req.method !== "POST") return text("method not allowed", 405);
@@ -31637,33 +32070,18 @@ async function handleUploadFiles(req) {
     if (file.size > MAX_UPLOAD_FILE_BYTES) return text("file too large", 413);
     total += file.size;
     if (total > MAX_UPLOAD_TOTAL_BYTES) return text("upload too large", 413);
-    const target = join23(realDir, safeName);
-    if (relative8(realDir, dirname6(target)) !== "")
+    const target = join24(realDir, safeName);
+    if (relative8(realDir, dirname7(target)) !== "")
       return text("invalid filename", 400);
-    if (existsSync8(target)) return text("file exists", 409);
+    if (existsSync9(target)) return text("file exists", 409);
     uploads.push({ file, name: safeName, target });
   }
-  const written = [];
   try {
-    for (const upload of uploads) {
-      const fd = openSync2(upload.target, uploadOpenFlags(), 420);
-      try {
-        writeFileSync2(fd, new Uint8Array(await upload.file.arrayBuffer()));
-      } finally {
-        closeSync2(fd);
-      }
-      written.push(upload.target);
-    }
+    await writeUploadedFiles(uploads);
   } catch (error) {
-    for (const path of written) {
-      try {
-        unlinkSync2(path);
-      } catch {
-      }
-    }
     if (error.code === "EEXIST")
-      return text("file exists", 409);
-    return text("upload failed", 500);
+      return text(formatErrorDetail(error), 409);
+    return text(formatErrorDetail(error), 500);
   }
   triggerUpdate(
     uploads.map((upload) => dir ? `${dir}/${upload.name}` : upload.name)
@@ -31674,78 +32092,6 @@ async function handleUploadFiles(req) {
     generation
   });
 }
-function openOsPath(path) {
-  const cmd = process.platform === "darwin" ? ["open", "--", path] : process.platform === "win32" ? ["explorer.exe", path] : ["xdg-open", path];
-  spawnDetached(cmd);
-}
-function windowsTrashScript(path) {
-  const quotedPath = path.replace(/'/g, "''");
-  return [
-    "$ErrorActionPreference = 'Stop';",
-    `$path = '${quotedPath}';`,
-    "Add-Type -TypeDefinition @'",
-    "using System;",
-    "using System.Runtime.InteropServices;",
-    "public static class CodeViewerRecycleBin {",
-    "  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]",
-    "  public struct SHFILEOPSTRUCT {",
-    "    public IntPtr hwnd;",
-    "    public uint wFunc;",
-    "    public string pFrom;",
-    "    public string pTo;",
-    "    public ushort fFlags;",
-    "    [MarshalAs(UnmanagedType.Bool)] public bool fAnyOperationsAborted;",
-    "    public IntPtr hNameMappings;",
-    "    public string lpszProgressTitle;",
-    "  }",
-    '  [DllImport("shell32.dll", CharSet = CharSet.Unicode)]',
-    "  private static extern int SHFileOperationW(ref SHFILEOPSTRUCT lpFileOp);",
-    "  public static void MoveToRecycleBin(string path) {",
-    "    const uint FO_DELETE = 0x0003;",
-    "    const ushort FOF_SILENT = 0x0004;",
-    "    const ushort FOF_NOCONFIRMATION = 0x0010;",
-    "    const ushort FOF_ALLOWUNDO = 0x0040;",
-    "    const ushort FOF_NOERRORUI = 0x0400;",
-    "    var op = new SHFILEOPSTRUCT {",
-    "      hwnd = IntPtr.Zero,",
-    "      wFunc = FO_DELETE,",
-    '      pFrom = path + "\\0\\0",',
-    "      pTo = null,",
-    "      fFlags = (ushort)(FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT),",
-    "      fAnyOperationsAborted = false,",
-    "      hNameMappings = IntPtr.Zero,",
-    "      lpszProgressTitle = null",
-    "    };",
-    "    int result = SHFileOperationW(ref op);",
-    '    if (result != 0) throw new InvalidOperationException("SHFileOperationW failed: " + result);',
-    '    if (op.fAnyOperationsAborted) throw new OperationCanceledException("SHFileOperationW aborted");',
-    "  }",
-    "}",
-    "'@;",
-    "[CodeViewerRecycleBin]::MoveToRecycleBin($path);"
-  ].join(" ");
-}
-function windowsRestoreTrashScript(originalPath) {
-  const quotedPath = originalPath.replace(/'/g, "''");
-  return [
-    "$ErrorActionPreference = 'Stop';",
-    `$original = '${quotedPath}';`,
-    "$parent = [System.IO.Path]::GetDirectoryName($original);",
-    "$name = [System.IO.Path]::GetFileName($original);",
-    "$shell = New-Object -ComObject Shell.Application;",
-    "$bin = $shell.Namespace(10);",
-    "$restored = $false;",
-    "foreach ($item in $bin.Items()) {",
-    "  $deletedFrom = $item.ExtendedProperty('System.Recycle.DeletedFrom');",
-    "  if ($item.Name -eq $name -and $deletedFrom -eq $parent) {",
-    "    $item.InvokeVerb('ESTORE');",
-    "    $restored = $true;",
-    "    break;",
-    "  }",
-    "}",
-    "if (-not $restored) { throw 'recycle bin item not found'; }"
-  ].join(" ");
-}
 function makeUndoId() {
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -31760,86 +32106,6 @@ function triggerUpdate(changedPaths) {
   const data = changedPaths?.length && changedPaths.length <= 50 ? JSON.stringify({ generation, paths: changedPaths }) : "tick";
   sendSse("update", data);
 }
-function moveMacPathIntoTrash(path) {
-  const trashDir = join23(homedir4(), ".Trash");
-  const base = basename4(path) || "code-viewer-trash-item";
-  const target = join23(
-    trashDir,
-    `${base}-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`
-  );
-  try {
-    mkdirSync4(trashDir, { recursive: true });
-    renameSync(path, target);
-    return { ok: true, trashPath: target };
-  } catch (error) {
-    return { ok: false, error: String(error) };
-  }
-}
-async function movePathToTrash(path) {
-  lstatSync5(path);
-  if (process.platform === "darwin") {
-    return moveMacPathIntoTrash(path);
-  }
-  if (process.platform === "win32") {
-    const res = await runAsync(
-      [
-        "powershell.exe",
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-Command",
-        windowsTrashScript(path)
-      ],
-      cwd,
-      { timeout: 6e4 }
-    );
-    return res.code === 0 ? { ok: true } : { ok: false, error: res.stderr || res.stdout };
-  }
-  return { ok: false, error: "trash unsupported" };
-}
-async function restoreTrashPath(originalPath, trashPath) {
-  const parent = parentRepoPath(originalPath);
-  const parentFullPath = safeOpenWorktreePath(parent);
-  if (!parentFullPath) return { ok: false, error: "invalid restore target" };
-  const original = worktreePath(originalPath);
-  if (existsSync8(original))
-    return { ok: false, error: "restore target exists" };
-  if (trashPath) {
-    if (process.platform !== "darwin")
-      return { ok: false, error: "invalid trash handle" };
-    if (!existsSync8(trashPath))
-      return { ok: false, error: "trash item not found" };
-    try {
-      const trashRoot = join23(homedir4(), ".Trash");
-      const trashRelative = relative8(trashRoot, trashPath);
-      if (trashRelative === "" || trashRelative.startsWith("..") || trashRelative.startsWith("/") || trashRelative.startsWith("\\"))
-        return { ok: false, error: "invalid trash handle" };
-      mkdirSync4(dirname6(original), { recursive: true });
-      renameSync(trashPath, original);
-      return { ok: true };
-    } catch (error) {
-      return { ok: false, error: String(error) };
-    }
-  }
-  if (process.platform === "win32") {
-    const res = await runAsync(
-      [
-        "powershell.exe",
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-Command",
-        windowsRestoreTrashScript(original)
-      ],
-      cwd,
-      { timeout: 6e4 }
-    );
-    return res.code === 0 ? { ok: true } : { ok: false, error: res.stderr || res.stdout };
-  }
-  return { ok: false, error: "undo unavailable for this trash operation" };
-}
 async function handleOpenPath(req) {
   if (req.method !== "POST") return text("method not allowed", 405);
   if (!sideEffectRequestAllowed2(req)) return text("forbidden", 403);
@@ -31868,7 +32134,12 @@ async function handleOpenPath(req) {
   if (!target) return text("not found", 404);
   const stats = statSync8(target);
   if (!stats.isDirectory()) return text("not a directory", 400);
-  openOsPath(target);
+  try {
+    await openDirectoryInOs(target);
+  } catch (error) {
+    console.error("[code-viewer] failed to open path in OS:", error);
+    return text(formatErrorDetail(error), 500);
+  }
   return json2({ ok: true });
 }
 async function handleTrashPath(req) {
@@ -31890,17 +32161,23 @@ async function handleTrashPath(req) {
   const path = typeof body.path === "string" ? body.path.replace(/^\/+|\/+$/g, "") : "";
   if (!path) return text("invalid path", 400);
   if (!safeRepoPath(path)) return text("invalid path", 400);
-  if (isGitInternalPath(path)) return text("forbidden", 403);
+  if (isGitInternalPath(path) || isCodeViewerInternalPath(path))
+    return text("forbidden", 403);
   const originalFullPath = safeWorktreePath2(path);
   if (!originalFullPath) return text("not found", 404);
   let changedPaths;
   try {
     const stats = statSync8(originalFullPath);
     if (!stats.isDirectory()) changedPaths = [path];
-  } catch {
+  } catch (error) {
+    return text(formatErrorDetail(error), 500);
+  }
+  let moved;
+  try {
+    moved = await movePathToTrash(worktreePath(path), cwd);
+  } catch (error) {
+    return text(formatErrorDetail(error), 500);
   }
-  const moved = await movePathToTrash(worktreePath(path));
-  if (!moved.ok) return text(moved.error || "trash failed", 500);
   const undo = {
     id: makeUndoId(),
     type: "trash",
@@ -31944,10 +32221,10 @@ async function handleCreateDirectory(req) {
   const targetPath = dir ? `${dir}/${name}` : name;
   if (!safeRepoPath(targetPath) || isGitInternalPath(targetPath))
     return text("invalid target", 400);
-  const target = join23(parent, name);
-  if (existsSync8(target)) return text("already exists", 409);
+  const target = join24(parent, name);
+  if (existsSync9(target)) return text("already exists", 409);
   try {
-    mkdirSync4(target, { recursive: false });
+    mkdirSync5(target, { recursive: false });
   } catch (error) {
     if (error.code === "EEXIST")
       return text("already exists", 409);
@@ -31976,14 +32253,22 @@ async function handleRestoreTrash(req) {
   const trashPath = typeof body.trashPath === "string" ? body.trashPath : "";
   if (!originalPath || !safeRepoPath(originalPath))
     return text("invalid restore target", 400);
-  if (isGitInternalPath(originalPath)) return text("forbidden", 403);
-  const restored = await restoreTrashPath(originalPath, trashPath || void 0);
-  if (!restored.ok) return text(restored.error || "undo failed", 409);
+  if (isGitInternalPath(originalPath) || isCodeViewerInternalPath(originalPath))
+    return text("forbidden", 403);
+  const parent = parentRepoPath(originalPath);
+  if (!safeOpenWorktreePath(parent)) return text("invalid restore target", 400);
+  const original = worktreePath(originalPath);
+  try {
+    await restorePathFromTrash(original, trashPath || void 0, cwd);
+  } catch (error) {
+    return text(formatErrorDetail(error), 409);
+  }
   let changedPaths;
   try {
-    const stats = statSync8(worktreePath(originalPath));
+    const stats = statSync8(original);
     if (!stats.isDirectory()) changedPaths = [originalPath];
-  } catch {
+  } catch (error) {
+    return text(formatErrorDetail(error), 500);
   }
   triggerUpdate(changedPaths);
   return json2({ ok: true, generation });
@@ -32480,10 +32765,6 @@ function closeSseClients() {
     }
   }
 }
-function openBrowser(url) {
-  const cmd = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd.exe", "/c", "start", "", url] : ["xdg-open", url];
-  spawnDetached(cmd);
-}
 async function shutdown(exitCode = 0) {
   if (shuttingDown) {
     process.exit(1);
@@ -32574,10 +32855,13 @@ var init_preview = __esm({
     init_command_resolver();
     init_dev_assets();
     init_doctor();
+    init_file_upload();
     init_git();
     init_github_issues();
     init_journal2();
     init_mcp();
+    init_os_opener();
+    init_os_trash();
     init_range();
     init_raw_file_headers();
     init_request_origin();
@@ -32589,8 +32873,8 @@ var init_preview = __esm({
     init_state_store();
     init_watch_supervisor();
     init_worktree_watcher();
-    WEB_ROOT = join23(ROOT, "web");
-    VERSION = JSON.parse(readFileSync8(join23(ROOT, "package.json"), "utf8")).version;
+    WEB_ROOT = join24(ROOT, "web");
+    VERSION = JSON.parse(readFileSync8(join24(ROOT, "package.json"), "utf8")).version;
     DEFAULT_ARGS = ["HEAD"];
     PREVIEW_HUNKS_DEFAULT = 3;
     PREVIEW_LINES_DEFAULT = 1200;
@@ -32828,7 +33112,7 @@ data: ${watchLimitReached}
     });
     listenPort = server.port;
     if (openAfterStart) {
-      openBrowser(`http://127.0.0.1:${server.port}/`);
+      await openUrlInOs(`http://127.0.0.1:${server.port}/`, cwd);
     }
     writeServerRegistry({
       url: `http://127.0.0.1:${server.port}/`,