@kmugalkhod/lightcode 0.14.0 → 0.16.0

package/server.js

@@ -428,6 +428,9 @@ import {
 } from "fs";
 import path4 from "path";
 import { z } from "zod";
+function isAuthenticatedWebRequest(request) {
+  return authenticatedWebRequests.has(request);
+}
 function defaultExpectedOrigin(env = Bun.env) {
   const configuredPort = env.PORT?.trim() || "4983";
   return new URL(`http://127.0.0.1:${configuredPort}`).origin;
@@ -603,6 +606,9 @@ function createWebSecurityMiddleware(options = {}) {
         if (!hasValidBearerToken(request, authState.token)) {
           return jsonSecurityError(c, 401, "web_auth_required", "A valid Lightcode browser token is required.");
         }
+        if (browserRequest) {
+          authenticatedWebRequests.add(request);
+        }
       } else if (browserRequest || authState.configured) {
         return jsonSecurityError(c, 503, "web_auth_unavailable", "Browser access is unavailable. Start Lightcode with `lightcode web`.");
       } else if (!allowUnauthenticatedCli) {
@@ -615,7 +621,7 @@ function createWebSecurityMiddleware(options = {}) {
     await next();
   };
 }
-var webAuthFileEnvironmentVariable = "LIGHTCODE_WEB_AUTH_FILE", webAuthHandoffSchema, maximumHandoffBytes = 4096, maximumHandoffAgeMs, maximumHandoffClockSkewMs, defaultAuthState;
+var webAuthFileEnvironmentVariable = "LIGHTCODE_WEB_AUTH_FILE", webAuthHandoffSchema, maximumHandoffBytes = 4096, maximumHandoffAgeMs, maximumHandoffClockSkewMs, authenticatedWebRequests, defaultAuthState;
 var init_web_auth = __esm(() => {
   webAuthHandoffSchema = z.object({
     version: z.literal(1),
@@ -624,6 +630,7 @@ var init_web_auth = __esm(() => {
   }).strict();
   maximumHandoffAgeMs = 5 * 60 * 1000;
   maximumHandoffClockSkewMs = 30 * 1000;
+  authenticatedWebRequests = new WeakSet;
   defaultAuthState = loadWebAuthStateFromEnvironment();
 });
 
@@ -9522,7 +9529,7 @@ var init_runtime16 = __esm(() => {
 
 // packages/ai/src/workspace-browser.ts
 import { z as z38 } from "zod";
-var workspaceLocationIdSchema, workspaceLocationStateSchema, workspaceLocationSchema, workspaceLocationsResponseSchema, workspaceBrowserOpenRequestSchema, workspaceBrowserIdSchema, workspaceBrowserOpenResponseSchema, workspacePathSegmentSchema, workspacePathSegmentsSchema, workspaceBrowserCursorSchema, workspaceBrowserEntriesRequestSchema, workspaceBrowserEntryKindSchema, workspaceBrowserSymlinkStateSchema, workspaceBrowserEntrySchema, workspaceBrowserEntriesResponseSchema, workspaceBrowserSelectRequestSchema, workspaceGrantIdSchema, workspaceGrantSchema, workspaceBrowserSelectResponseSchema, workspaceSessionPathParamsSchema, workspaceSessionCreateRequestSchema, workspaceBrowserPathParamsSchema, workspaceApiErrorCodeSchema, workspaceApiErrorResponseSchema;
+var workspaceLocationIdSchema, workspaceLocationStateSchema, workspaceLocationSchema, workspaceLocationsResponseSchema, workspaceBrowserOpenRequestSchema, workspaceBrowserIdSchema, workspaceBrowserOpenResponseSchema, workspacePathSegmentSchema, workspacePathSegmentsSchema, workspaceBrowserCursorSchema, workspaceBrowserEntriesRequestSchema, workspaceBrowserEntryKindSchema, workspaceBrowserSymlinkStateSchema, workspaceBrowserEntrySchema, workspaceBrowserEntriesResponseSchema, workspaceBrowserSelectRequestSchema, workspaceGrantIdSchema, workspaceGrantSchema, workspaceNativePickerRequestSchema, workspaceNativePickerResponseSchema, workspaceBrowserSelectResponseSchema, workspaceSessionPathParamsSchema, workspaceSessionCreateRequestSchema, workspaceBrowserPathParamsSchema, workspaceApiErrorCodeSchema, workspaceApiErrorResponseSchema;
 var init_workspace_browser = __esm(() => {
   init_coding_agent_modes();
   init_permissions();
@@ -9604,6 +9611,16 @@ var init_workspace_browser = __esm(() => {
     pathLabel: z38.string().min(1).max(4096),
     createdAt: z38.string().min(1)
   }).strict();
+  workspaceNativePickerRequestSchema = z38.object({}).strict();
+  workspaceNativePickerResponseSchema = z38.discriminatedUnion("outcome", [
+    z38.object({
+      outcome: z38.literal("selected"),
+      workspace: workspaceGrantSchema
+    }).strict(),
+    z38.object({
+      outcome: z38.literal("cancelled")
+    }).strict()
+  ]);
   workspaceBrowserSelectResponseSchema = z38.object({
     workspace: workspaceGrantSchema
   }).strict();
@@ -9631,7 +9648,10 @@ var init_workspace_browser = __esm(() => {
     "browser_capability_expired",
     "workspace_grant_not_found",
     "invalid_cursor",
-    "workspace_unavailable"
+    "workspace_unavailable",
+    "native_picker_busy",
+    "native_picker_unavailable",
+    "native_picker_failed"
   ]);
   workspaceApiErrorResponseSchema = z38.object({
     error: z38.string().min(1),
@@ -16799,6 +16819,320 @@ var init_web_routes = __esm(() => {
   }).get("/app/*", serveWebAsset);
 });
 
+// apps/server/src/lib/native-directory-picker.ts
+import path24 from "path";
+import { accessSync, constants as fsConstants2 } from "fs";
+import { homedir as homedir4 } from "os";
+async function readBoundedStream(stream, maximumBytes) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maximumBytes) {
+        throw new PickerOutputTooLargeError;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const output = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(output);
+}
+function stripToolLineEnding(value) {
+  return value.endsWith(`\r
+`) ? value.slice(0, -2) : value.endsWith(`
+`) ? value.slice(0, -1) : value;
+}
+function assertPickerPath(value, pathApi) {
+  const windowsRoot = pathApi === path24.win32 ? path24.win32.parse(value).root : null;
+  const isFullyQualifiedWindowsPath = windowsRoot === null || /^[A-Za-z]:[\\/]$/.test(windowsRoot) || /^\\\\(?![?.][\\/])[^\\/]+[\\/][^\\/]+[\\/]$/.test(windowsRoot);
+  if (value.length === 0 || value.length > 4096 || value.includes("\x00") || !pathApi.isAbsolute(value) || !isFullyQualifiedWindowsPath) {
+    throw new NativeDirectoryPickerError("native_picker_failed", "The system folder picker returned an invalid folder.");
+  }
+  return value;
+}
+function parseWindowsResult(result) {
+  const output = stripToolLineEnding(result.stdout);
+  if (result.exitCode !== 0) {
+    throw new NativeDirectoryPickerError("native_picker_failed", "The Windows folder picker could not be opened.");
+  }
+  if (output === "cancelled")
+    return { outcome: "cancelled" };
+  if (!output.startsWith("selected:")) {
+    throw new NativeDirectoryPickerError("native_picker_failed", "The Windows folder picker returned an invalid response.");
+  }
+  const encoded = output.slice("selected:".length);
+  if (!encoded || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) {
+    throw new NativeDirectoryPickerError("native_picker_failed", "The Windows folder picker returned an invalid response.");
+  }
+  try {
+    const directory = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.from(encoded, "base64"));
+    if (Buffer.from(directory, "utf8").toString("base64").replace(/=+$/, "") !== encoded.replace(/=+$/, "")) {
+      throw new Error("invalid base64");
+    }
+    return {
+      outcome: "selected",
+      directory: assertPickerPath(directory, path24.win32)
+    };
+  } catch (error) {
+    if (error instanceof NativeDirectoryPickerError)
+      throw error;
+    throw new NativeDirectoryPickerError("native_picker_failed", "The Windows folder picker returned an invalid response.");
+  }
+}
+function parseMacosResult(result) {
+  if (result.exitCode !== 0) {
+    if (/\(-128\)|user canceled/i.test(result.stderr)) {
+      return { outcome: "cancelled" };
+    }
+    throw new NativeDirectoryPickerError("native_picker_failed", "The macOS folder picker could not be opened.");
+  }
+  return {
+    outcome: "selected",
+    directory: assertPickerPath(stripToolLineEnding(result.stdout), path24.posix)
+  };
+}
+function parseLinuxResult(result) {
+  if (result.exitCode === 1)
+    return { outcome: "cancelled" };
+  if (result.exitCode !== 0) {
+    throw new NativeDirectoryPickerError("native_picker_failed", "The Linux folder picker could not be opened.");
+  }
+  return {
+    outcome: "selected",
+    directory: assertPickerPath(stripToolLineEnding(result.stdout), path24.posix)
+  };
+}
+function resolvePickerCommand({
+  platform: platform4,
+  environment,
+  which
+}) {
+  if (platform4 === "win32") {
+    const configuredRoot = environment.SystemRoot?.trim();
+    const systemRoot = configuredRoot && path24.win32.isAbsolute(configuredRoot) ? configuredRoot : "C:\\Windows";
+    const candidate = path24.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    const executable = which(candidate);
+    if (!executable || !path24.win32.isAbsolute(executable))
+      return null;
+    return {
+      kind: "windows",
+      argv: [
+        executable,
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-STA",
+        "-EncodedCommand",
+        Buffer.from(windowsPickerScript, "utf16le").toString("base64")
+      ]
+    };
+  }
+  if (platform4 === "darwin") {
+    const executable = which("/usr/bin/osascript");
+    if (!executable || !path24.posix.isAbsolute(executable))
+      return null;
+    return {
+      kind: "macos",
+      argv: [executable, "-e", macosPickerScript]
+    };
+  }
+  if (platform4 === "linux") {
+    if (!environment.DISPLAY?.trim() && !environment.WAYLAND_DISPLAY?.trim()) {
+      return null;
+    }
+    const desktop = environment.XDG_CURRENT_DESKTOP?.toLowerCase() ?? "";
+    const candidates = desktop.includes("kde") ? ["kdialog", "zenity"] : ["zenity", "kdialog"];
+    for (const command of candidates) {
+      let executable = null;
+      for (const directory of trustedLinuxExecutableDirectories) {
+        const candidate = path24.posix.join(directory, command);
+        const resolved = which(candidate);
+        if (resolved === candidate) {
+          executable = resolved;
+          break;
+        }
+      }
+      if (!executable)
+        continue;
+      if (command === "zenity") {
+        return {
+          kind: "zenity",
+          argv: [
+            executable,
+            "--file-selection",
+            "--directory",
+            "--title=Choose a project folder"
+          ]
+        };
+      }
+      return {
+        kind: "kdialog",
+        argv: [
+          executable,
+          "--title",
+          "Choose a project folder",
+          "--getexistingdirectory",
+          path24.posix.isAbsolute(homedir4()) ? homedir4() : "/"
+        ]
+      };
+    }
+  }
+  return null;
+}
+function createNativeDirectoryPicker(options = {}) {
+  const platform4 = options.platform ?? process.platform;
+  const environment = options.environment ?? Bun.env;
+  const which = options.which ?? ((candidate) => {
+    try {
+      accessSync(candidate, fsConstants2.X_OK);
+      return candidate;
+    } catch {
+      return null;
+    }
+  });
+  const runProcess = options.runProcess ?? runNativePickerProcess;
+  let active = false;
+  return {
+    async pick(signal) {
+      if (active) {
+        throw new NativeDirectoryPickerError("native_picker_busy", "A folder picker is already open.");
+      }
+      if (signal?.aborted)
+        return { outcome: "cancelled" };
+      const command = resolvePickerCommand({ platform: platform4, environment, which });
+      if (!command) {
+        throw new NativeDirectoryPickerError("native_picker_unavailable", "No supported system folder picker is available.");
+      }
+      active = true;
+      try {
+        const result = await runProcess(command.argv, signal);
+        if (signal?.aborted)
+          return { outcome: "cancelled" };
+        if (command.kind === "windows")
+          return parseWindowsResult(result);
+        if (command.kind === "macos")
+          return parseMacosResult(result);
+        return parseLinuxResult(result);
+      } catch (error) {
+        if (error instanceof NativeDirectoryPickerError)
+          throw error;
+        throw new NativeDirectoryPickerError("native_picker_failed", "The system folder picker could not be opened.");
+      } finally {
+        active = false;
+      }
+    }
+  };
+}
+var maximumPickerOutputBytes, NativeDirectoryPickerError, trustedLinuxExecutableDirectories, PickerOutputTooLargeError, runNativePickerProcess = async (command, signal) => {
+  if (signal?.aborted) {
+    return { exitCode: 1, stdout: "", stderr: "" };
+  }
+  const child = Bun.spawn([...command], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    windowsHide: true
+  });
+  let aborted = false;
+  const abort = () => {
+    aborted = true;
+    try {
+      child.kill();
+    } catch {}
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted)
+    abort();
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      readBoundedStream(child.stdout, maximumPickerOutputBytes),
+      readBoundedStream(child.stderr, maximumPickerOutputBytes),
+      child.exited
+    ]);
+    return {
+      exitCode: aborted ? 1 : exitCode,
+      stdout: aborted ? "" : stdout,
+      stderr: aborted ? "" : stderr
+    };
+  } catch (error) {
+    abort();
+    if (error instanceof PickerOutputTooLargeError) {
+      throw new NativeDirectoryPickerError("native_picker_failed", "The system folder picker returned an invalid response.");
+    }
+    throw error;
+  } finally {
+    signal?.removeEventListener("abort", abort);
+  }
+}, windowsPickerScript, macosPickerScript;
+var init_native_directory_picker = __esm(() => {
+  maximumPickerOutputBytes = 16 * 1024;
+  NativeDirectoryPickerError = class NativeDirectoryPickerError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+      this.name = "NativeDirectoryPickerError";
+    }
+  };
+  trustedLinuxExecutableDirectories = [
+    "/usr/bin",
+    "/bin",
+    "/run/current-system/sw/bin"
+  ];
+  PickerOutputTooLargeError = class PickerOutputTooLargeError extends Error {
+  };
+  windowsPickerScript = String.raw`
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)
+Add-Type -AssemblyName System.Windows.Forms
+$dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+$dialog.Description = 'Choose a project folder'
+$dialog.ShowNewFolderButton = $true
+$dialog.AutoUpgradeEnabled = $true
+$owner = New-Object System.Windows.Forms.Form
+$owner.TopMost = $true
+$owner.ShowInTaskbar = $false
+$owner.StartPosition = [System.Windows.Forms.FormStartPosition]::Manual
+$owner.Location = New-Object System.Drawing.Point(-32000, -32000)
+$owner.Size = New-Object System.Drawing.Size(1, 1)
+$owner.Opacity = 0
+try {
+  $owner.Show()
+  $owner.Activate()
+  $result = $dialog.ShowDialog($owner)
+  if ($result -eq [System.Windows.Forms.DialogResult]::OK) {
+    $bytes = [Text.Encoding]::UTF8.GetBytes($dialog.SelectedPath)
+    [Console]::Out.Write('selected:' + [Convert]::ToBase64String($bytes))
+  } else {
+    [Console]::Out.Write('cancelled')
+  }
+} finally {
+  $dialog.Dispose()
+  $owner.Dispose()
+}
+`;
+  macosPickerScript = String.raw`
+try
+  set chosenFolder to choose folder with prompt "Choose a project folder"
+  return POSIX path of chosenFolder
+on error number -128
+  error number -128
+end try
+`;
+});
+
 // apps/server/src/routes/workspace-routes.ts
 import { zValidator as zValidator3 } from "@hono/zod-validator";
 import {
@@ -16807,12 +17141,17 @@ import {
   randomBytes,
   timingSafeEqual as timingSafeEqual2
 } from "crypto";
-import { constants as fsConstants2, promises as fs8 } from "fs";
-import { homedir as homedir4 } from "os";
-import path24 from "path";
+import { constants as fsConstants3, promises as fs8 } from "fs";
+import { homedir as homedir5 } from "os";
+import path25 from "path";
 import { Hono as Hono7 } from "hono";
 function pathImplementation(platform4) {
-  return platform4 === "win32" ? path24.win32 : path24.posix;
+  return platform4 === "win32" ? path25.win32 : path25.posix;
+}
+function isFilesystemRootPath(candidate, platform4 = process.platform) {
+  const pathApi = pathImplementation(platform4);
+  const normalized = pathApi.normalize(candidate);
+  return normalized === pathApi.parse(normalized).root;
 }
 function normalizeKnownFolderCandidate(candidate, platform4) {
   if (candidate.includes("\x00")) {
@@ -16823,7 +17162,7 @@ function normalizeKnownFolderCandidate(candidate, platform4) {
     return null;
   }
   const normalized = pathApi.normalize(candidate);
-  if (normalized === pathApi.parse(normalized).root) {
+  if (isFilesystemRootPath(normalized, platform4)) {
     return null;
   }
   return normalized;
@@ -16841,10 +17180,10 @@ async function probeDirectory(candidate) {
   }
 }
 async function readSmallUserDirsConfiguration(filePath) {
-  const noFollowFlag = typeof fsConstants2.O_NOFOLLOW === "number" ? fsConstants2.O_NOFOLLOW : 0;
+  const noFollowFlag = typeof fsConstants3.O_NOFOLLOW === "number" ? fsConstants3.O_NOFOLLOW : 0;
   let handle;
   try {
-    handle = await fs8.open(filePath, fsConstants2.O_RDONLY | noFollowFlag);
+    handle = await fs8.open(filePath, fsConstants3.O_RDONLY | noFollowFlag);
     const metadata = await handle.stat();
     if (!metadata.isFile() || metadata.size <= 0 || metadata.size > maximumUserDirsConfigurationBytes) {
       return null;
@@ -16865,8 +17204,8 @@ async function resolveWindowsKnownFolder(environment, folder) {
     if (!windowsRoot) {
       return null;
     }
-    const systemDirectory = path24.win32.join(windowsRoot, "System32");
-    const executable = path24.win32.join(systemDirectory, "WindowsPowerShell", "v1.0", "powershell.exe");
+    const systemDirectory = path25.win32.join(windowsRoot, "System32");
+    const executable = path25.win32.join(systemDirectory, "WindowsPowerShell", "v1.0", "powershell.exe");
     const folderExpression = folder === "desktop" ? "[Environment]::GetFolderPath([Environment+SpecialFolder]::DesktopDirectory)" : folder === "documents" ? "[Environment]::GetFolderPath([Environment+SpecialFolder]::MyDocuments)" : "[Environment]::ExpandEnvironmentVariables([string](Get-ItemProperty -LiteralPath 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders' -Name '{374DE290-123F-4565-9164-39C4925E467B}' -ErrorAction Stop).'{374DE290-123F-4565-9164-39C4925E467B}')";
     const child = Bun.spawn([
       executable,
@@ -16925,15 +17264,15 @@ function parseXdgUserDirectory(contents, homeDirectory, variableName) {
       return null;
     }
     if (configured.startsWith("$HOME/")) {
-      return path24.posix.resolve(homeDirectory, configured.slice(6));
+      return path25.posix.resolve(homeDirectory, configured.slice(6));
     }
     if (configured.startsWith("${HOME}/")) {
-      return path24.posix.resolve(homeDirectory, configured.slice(8));
+      return path25.posix.resolve(homeDirectory, configured.slice(8));
     }
     if (configured.includes("$")) {
       return null;
     }
-    return path24.posix.isAbsolute(configured) ? path24.posix.normalize(configured) : null;
+    return path25.posix.isAbsolute(configured) ? path25.posix.normalize(configured) : null;
   }
   return null;
 }
@@ -16963,7 +17302,7 @@ async function resolveDesktopDirectoryPath(options = {}) {
   const platform4 = options.platform ?? process.platform;
   const pathApi = pathImplementation(platform4);
   const environment = options.environment ?? Bun.env;
-  const homeDirectory = pathApi.normalize(options.homeDirectory ?? homedir4());
+  const homeDirectory = pathApi.normalize(options.homeDirectory ?? homedir5());
   const explicit = environment.LIGHTCODE_DESKTOP_PATH?.trim();
   if (explicit) {
     const normalized = normalizeKnownFolderCandidate(explicit, platform4);
@@ -16987,17 +17326,17 @@ async function resolveDesktopDirectoryPath(options = {}) {
         return [];
       }
       return [
-        index === 0 ? trimmed : path24.win32.join(trimmed, "Desktop")
+        index === 0 ? trimmed : path25.win32.join(trimmed, "Desktop")
       ];
     });
-    candidates.push(path24.win32.join(userProfile, "Desktop"));
-    return await firstUsableKnownFolder(candidates, platform4, probe) ?? path24.win32.join(homeDirectory, "Desktop");
+    candidates.push(path25.win32.join(userProfile, "Desktop"));
+    return await firstUsableKnownFolder(candidates, platform4, probe) ?? path25.win32.join(homeDirectory, "Desktop");
   }
   if (platform4 === "linux") {
     const configHome = environment.XDG_CONFIG_HOME?.trim();
-    const safeConfigHome = configHome && path24.posix.isAbsolute(configHome) ? path24.posix.normalize(configHome) : path24.posix.join(homeDirectory, ".config");
+    const safeConfigHome = configHome && path25.posix.isAbsolute(configHome) ? path25.posix.normalize(configHome) : path25.posix.join(homeDirectory, ".config");
     const readConfiguration = options.readUserDirsConfiguration ?? readSmallUserDirsConfiguration;
-    const contents = await readConfiguration(path24.posix.join(safeConfigHome, "user-dirs.dirs"));
+    const contents = await readConfiguration(path25.posix.join(safeConfigHome, "user-dirs.dirs"));
     const configured = contents ? parseXdgUserDirectory(contents, homeDirectory, "XDG_DESKTOP_DIR") : null;
     if (configured) {
       const selected = await firstUsableKnownFolder([configured], platform4, probe);
@@ -17012,7 +17351,7 @@ async function resolveUserDirectoryPath(folder, options) {
   const platform4 = options.platform ?? process.platform;
   const pathApi = pathImplementation(platform4);
   const environment = options.environment ?? Bun.env;
-  const homeDirectory = pathApi.normalize(options.homeDirectory ?? homedir4());
+  const homeDirectory = pathApi.normalize(options.homeDirectory ?? homedir5());
   const displayName = folder === "documents" ? "Documents" : "Downloads";
   const overrideName = folder === "documents" ? "LIGHTCODE_DOCUMENTS_PATH" : "LIGHTCODE_DOWNLOADS_PATH";
   const explicit = environment[overrideName]?.trim();
@@ -17034,17 +17373,17 @@ async function resolveUserDirectoryPath(folder, options) {
     ];
     const candidates = [
       knownFolder,
-      ...cloudRoots.map((root) => root?.trim() ? path24.win32.join(root.trim(), displayName) : null),
-      path24.win32.join(userProfile, displayName),
-      path24.win32.join(homeDirectory, displayName)
+      ...cloudRoots.map((root) => root?.trim() ? path25.win32.join(root.trim(), displayName) : null),
+      path25.win32.join(userProfile, displayName),
+      path25.win32.join(homeDirectory, displayName)
     ];
-    return await firstUsableKnownFolder(candidates, platform4, probe) ?? path24.win32.join(homeDirectory, displayName);
+    return await firstUsableKnownFolder(candidates, platform4, probe) ?? path25.win32.join(homeDirectory, displayName);
   }
   if (platform4 === "linux") {
     const configHome = environment.XDG_CONFIG_HOME?.trim();
-    const safeConfigHome = configHome && path24.posix.isAbsolute(configHome) ? path24.posix.normalize(configHome) : path24.posix.join(homeDirectory, ".config");
+    const safeConfigHome = configHome && path25.posix.isAbsolute(configHome) ? path25.posix.normalize(configHome) : path25.posix.join(homeDirectory, ".config");
     const readConfiguration = options.readUserDirsConfiguration ?? readSmallUserDirsConfiguration;
-    const contents = await readConfiguration(path24.posix.join(safeConfigHome, "user-dirs.dirs"));
+    const contents = await readConfiguration(path25.posix.join(safeConfigHome, "user-dirs.dirs"));
     const configured = contents ? parseXdgUserDirectory(contents, homeDirectory, folder === "documents" ? "XDG_DOCUMENTS_DIR" : "XDG_DOWNLOAD_DIR") : null;
     const selected = await firstUsableKnownFolder([configured], platform4, probe);
     if (selected) {
@@ -17063,7 +17402,7 @@ async function resolveProjectsDirectoryPath(options = {}) {
   const platform4 = options.platform ?? process.platform;
   const pathApi = pathImplementation(platform4);
   const environment = options.environment ?? Bun.env;
-  const homeDirectory = pathApi.normalize(options.homeDirectory ?? homedir4());
+  const homeDirectory = pathApi.normalize(options.homeDirectory ?? homedir5());
   const explicit = environment.LIGHTCODE_PROJECTS_PATH?.trim();
   if (explicit) {
     const normalized = normalizeKnownFolderCandidate(explicit, platform4);
@@ -17114,11 +17453,23 @@ function mapFilesystemError(error) {
   }
   return new WorkspaceRouteError("workspace_unavailable", "Unable to access the selected workspace.", 500, true);
 }
+function mapNativePickerError(error) {
+  if (!(error instanceof NativeDirectoryPickerError)) {
+    return new WorkspaceRouteError("native_picker_failed", "The system folder picker could not be opened.", 500, true);
+  }
+  if (error.code === "native_picker_busy") {
+    return new WorkspaceRouteError(error.code, "A folder picker is already open.", 409, true);
+  }
+  if (error.code === "native_picker_unavailable") {
+    return new WorkspaceRouteError(error.code, "No supported system folder picker is available.", 503, false);
+  }
+  return new WorkspaceRouteError(error.code, "The system folder picker could not be opened.", 500, true);
+}
 function workspaceErrorResponse(c, error) {
   const mapped = error instanceof WorkspaceRouteError ? error : mapFilesystemError(error);
   if (mapped.status === 500) {
     logger13.error("workspace_request_failed", {
-      error: getErrorMessage(error)
+      error: getErrorMessage(mapped)
     });
   }
   return c.json({
@@ -17144,13 +17495,13 @@ function identitiesMatch(left, right) {
   return left.device === right.device && left.inode === right.inode;
 }
 function isContainedPath2(root, candidate) {
-  const relative = path24.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path24.sep}`) && !path24.isAbsolute(relative);
+  const relative = path25.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path25.sep}`) && !path25.isAbsolute(relative);
 }
 async function resolveKnownDirectory(directory) {
   try {
-    const root = await fs8.realpath(path24.resolve(directory));
-    if (root === path24.parse(root).root) {
+    const root = await fs8.realpath(path25.resolve(directory));
+    if (isFilesystemRootPath(root)) {
       throw new WorkspaceRouteError("workspace_unavailable", "A filesystem root cannot be opened as a workspace location.", 500, false);
     }
     const stats = await fs8.stat(root, { bigint: true });
@@ -17199,7 +17550,7 @@ async function symlinkFailure(root, candidate, locationName) {
 async function resolveDirectoryFromSegments(root, segments, locationName) {
   let current = root;
   for (const segment of segments) {
-    const candidate = path24.join(current, segment);
+    const candidate = path25.join(current, segment);
     if (!isContainedPath2(root, candidate)) {
       throw new WorkspaceRouteError("workspace_symlink_escape", `The requested path is outside the allowed ${locationName} location.`, 403, false);
     }
@@ -17302,7 +17653,7 @@ function decodeCursor(secret, cursor, binding) {
   }
 }
 async function describeEntry(root, directory, name) {
-  const candidate = path24.join(directory, name);
+  const candidate = path25.join(directory, name);
   try {
     const stats = await fs8.lstat(candidate);
     if (stats.isSymbolicLink()) {
@@ -17326,7 +17677,7 @@ async function describeEntry(root, directory, name) {
       }
     }
     const kind = stats.isDirectory() ? "directory" : stats.isFile() ? "file" : "other";
-    const requiredAccess = stats.isDirectory() ? fsConstants2.R_OK | fsConstants2.X_OK : fsConstants2.R_OK;
+    const requiredAccess = stats.isDirectory() ? fsConstants3.R_OK | fsConstants3.X_OK : fsConstants3.R_OK;
     const readable = await fs8.access(candidate, requiredAccess).then(() => true).catch(() => false);
     return {
       name,
@@ -17382,7 +17733,7 @@ function createWorkspaceRoutes(options = {}) {
     return normalized;
   } : () => resolveDesktopDirectoryPath());
   const desktopPathLabel = options.desktopPathLabel ?? "Desktop";
-  const defaultHomePath = async () => homedir4();
+  const defaultHomePath = async () => homedir5();
   const defaultDocumentsPath = () => resolveDocumentsDirectoryPath();
   const defaultDownloadsPath = () => resolveDownloadsDirectoryPath();
   const definitions = [
@@ -17424,6 +17775,8 @@ function createWorkspaceRoutes(options = {}) {
   ];
   const definitionsById = new Map(definitions.map((definition) => [definition.id, definition]));
   const createSession = options.createSession ?? createChatSession;
+  const nativeDirectoryPicker = options.nativeDirectoryPicker ?? createNativeDirectoryPicker();
+  const authorizeNativePickerRequest = options.authorizeNativePickerRequest ?? isAuthenticatedWebRequest;
   const cursorSecret = randomBytes(32);
   const browserCapabilities = new Map;
   const workspaceGrants = new Map;
@@ -17442,7 +17795,70 @@ function createWorkspaceRoutes(options = {}) {
     }
     return grant;
   };
-  return new Hono7().get("/locations", (c) => c.json(workspaceLocationsResponseSchema.parse({
+  const storeWorkspaceGrant = async ({
+    root,
+    identity,
+    name,
+    pathLabel
+  }) => {
+    await fs8.access(root, fsConstants3.R_OK | fsConstants3.X_OK);
+    const createdAt = new Date(now()).toISOString();
+    const id = crypto.randomUUID();
+    const grant = {
+      id,
+      name,
+      pathLabel,
+      createdAt,
+      root,
+      identity
+    };
+    workspaceGrants.set(id, grant);
+    trimOldestEntries(workspaceGrants, maximumWorkspaceGrants);
+    try {
+      await assertRootIdentity(grant);
+    } catch (error) {
+      workspaceGrants.delete(id);
+      throw error;
+    }
+    return workspaceGrantSchema.parse({ id, name, pathLabel, createdAt });
+  };
+  return new Hono7().post("/picker/open", zValidator3("json", workspaceNativePickerRequestSchema, (result, c) => {
+    if (!result.success) {
+      return invalidRequestResponse(c);
+    }
+  }), async (c) => {
+    if (!authorizeNativePickerRequest(c.req.raw)) {
+      return c.json({
+        error: "The system folder picker is available only to an authenticated Lightcode web session.",
+        code: "web_browser_required"
+      }, 403);
+    }
+    try {
+      let picked;
+      try {
+        picked = await nativeDirectoryPicker.pick(c.req.raw.signal);
+      } catch (error) {
+        throw mapNativePickerError(error);
+      }
+      if (picked.outcome === "cancelled") {
+        return c.json(workspaceNativePickerResponseSchema.parse({
+          outcome: "cancelled"
+        }), 200);
+      }
+      const directory = await resolveKnownDirectory(picked.directory);
+      const workspace = await storeWorkspaceGrant({
+        ...directory,
+        name: path25.basename(directory.root),
+        pathLabel: directory.root
+      });
+      return c.json(workspaceNativePickerResponseSchema.parse({
+        outcome: "selected",
+        workspace
+      }), 201);
+    } catch (error) {
+      return workspaceErrorResponse(c, error);
+    }
+  }).get("/locations", (c) => c.json(workspaceLocationsResponseSchema.parse({
     locations: definitions.map((definition) => knownLocation(definition, "unprobed"))
   }))).post("/browser/open", zValidator3("json", workspaceBrowserOpenRequestSchema, (result, c) => {
     if (!result.success) {
@@ -17578,37 +17994,19 @@ function createWorkspaceRoutes(options = {}) {
         operation: "select",
         directory: directory.path
       });
-      await fs8.access(directory.path, fsConstants2.R_OK | fsConstants2.X_OK);
-      const createdAt = new Date(now()).toISOString();
-      const id = crypto.randomUUID();
       const name = segments.at(-1) ?? capability2.rootName;
       const pathLabel = [
         capability2.location.pathLabel,
         ...segments
       ].join("/");
-      const grant = {
-        id,
-        name,
-        pathLabel,
-        createdAt,
+      const workspace = await storeWorkspaceGrant({
         root: directory.path,
-        identity: directory.identity
-      };
-      workspaceGrants.set(id, grant);
-      trimOldestEntries(workspaceGrants, maximumWorkspaceGrants);
-      try {
-        await assertRootIdentity(grant);
-      } catch (error) {
-        workspaceGrants.delete(id);
-        throw error;
-      }
+        identity: directory.identity,
+        name,
+        pathLabel
+      });
       return c.json(workspaceBrowserSelectResponseSchema.parse({
-        workspace: workspaceGrantSchema.parse({
-          id,
-          name,
-          pathLabel,
-          createdAt
-        })
+        workspace
       }), 201);
     } catch (error) {
       return workspaceErrorResponse(c, error);
@@ -17646,6 +18044,8 @@ var init_workspace_routes = __esm(() => {
   init_src();
   init_chat_store();
   init_runtime_config();
+  init_native_directory_picker();
+  init_web_auth();
   logger13 = createLogger("workspace-routes");
   defaultBrowserCapabilityTtlMs = 10 * 60 * 1000;
   maximumUserDirsConfigurationBytes = 16 * 1024;