@hunsu/bridge 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -361,6 +361,7 @@ export type StudioServerOptions = {
     roadmapRegistryPath?: string;
     runtimeConfig?: BridgeRuntimeConfig;
     security?: StudioServerSecurityOptions;
+    directoryPicker?: NativeDirectoryPicker;
 };
 export type StudioCommandResult = {
     acceptedEvents: DomainEvent[];
@@ -455,6 +456,29 @@ export type FilesystemGrantRequest = {
 export type FilesystemGrantResult = {
     capability: FilesystemBrowseCapability;
 };
+export type NativeDirectoryPickerOptions = {
+    cwd: string;
+};
+export type NativeDirectoryPickerResult = {
+    status: "selected";
+    path: string;
+} | {
+    status: "cancelled";
+} | {
+    status: "unavailable";
+    reason: string;
+};
+export type NativeDirectoryPicker = (options: NativeDirectoryPickerOptions) => Promise<NativeDirectoryPickerResult>;
+export type FilesystemDirectoryPickResult = {
+    status: "selected";
+    capability: FilesystemBrowseCapability;
+    entry: FilesystemBrowseEntry;
+} | {
+    status: "cancelled";
+} | {
+    status: "unavailable";
+    reason: string;
+};
 export type MoveFileNode = {
     kind: "directory";
     name: string;
@@ -914,6 +938,11 @@ export declare function createFilesystemBrowseGrant(request: FilesystemGrantRequ
 export declare function tryCreateFilesystemBrowseGrant(request: FilesystemGrantRequest, state: StudioServerState, options?: {
     cwd?: string;
 }): Result<FilesystemGrantResult, FilesystemBrowseError>;
+export declare function pickFilesystemDirectory(state: StudioServerState, options?: {
+    cwd?: string;
+    picker?: NativeDirectoryPicker;
+}): Promise<FilesystemDirectoryPickResult>;
+export declare function openNativeDirectoryPicker(_options: NativeDirectoryPickerOptions): Promise<NativeDirectoryPickerResult>;
 export declare function createRouteWorktree(cwd: string, routeId: string, createdAt?: string, requestedBaseRef?: string, requestedWorktreeRoot?: string): WorktreeRef;
 export declare function createExecuteWorktree(cwd: string, executeId: string, createdAt?: string, requestedBaseRef?: string, requestedWorktreeRoot?: string): WorktreeRef;
 export declare function readMoveDiff(board: BoardProjection, moveId: string, cwd?: string): MoveDiff;

package/dist/index.js

@@ -167,7 +167,7 @@ function createStudioServerSecurity(options, runtimeConfig) {
         allowNoOrigin: options?.allowNoOrigin ?? true
     };
 }
-function evaluateStudioRequestSecurity(request, url, security) {
+function evaluateStudioRequestSecurity(request, url, security, options = {}) {
     const origin = requestHeader(request, "origin");
     const corsHeaders = corsHeadersForOrigin(origin, security);
     if (origin && corsHeaders === undefined) {
@@ -187,7 +187,7 @@ function evaluateStudioRequestSecurity(request, url, security) {
         };
     }
     const headers = corsHeaders ?? baseCorsHeaders();
-    if (security.authToken && !isPublicBridgeRequest(url) && !hasValidBridgeApiToken(request, url, security.authToken)) {
+    if (!options.skipAuth && security.authToken && !isPublicBridgeRequest(url) && !hasValidBridgeApiToken(request, url, security.authToken)) {
         return {
             allowed: false,
             status: 401,
@@ -662,11 +662,13 @@ export function createStudioServer(options = {}) {
     const runner = options.runner ?? createConfiguredRunner(runtimeConfig);
     const actionRunner = options.actionRunner;
     const security = createStudioServerSecurity(options.security, runtimeConfig);
+    const directoryPicker = options.directoryPicker ?? openNativeDirectoryPicker;
+    let activeDirectoryPick = false;
     return createServer(async (request, response) => {
         try {
             const url = new URL(request.url ?? "/", "http://localhost");
             const pathname = url.pathname;
-            const requestSecurity = evaluateStudioRequestSecurity(request, url, security);
+            const requestSecurity = evaluateStudioRequestSecurity(request, url, security, { skipAuth: request.method === "OPTIONS" });
             responseSecurityHeaders.set(response, requestSecurity.corsHeaders);
             if (request.method === "OPTIONS") {
                 sendJson(response, requestSecurity.allowed ? 204 : requestSecurity.status ?? 403, requestSecurity.allowed ? {} : { error: requestSecurity.error ?? "Origin is not allowed." });
@@ -699,6 +701,20 @@ export function createStudioServer(options = {}) {
                 }));
                 return;
             }
+            if (request.method === "POST" && pathname === "/api/filesystem/pick-directory") {
+                if (activeDirectoryPick) {
+                    sendJson(response, 409, { status: "unavailable", reason: "A folder picker is already open." });
+                    return;
+                }
+                activeDirectoryPick = true;
+                try {
+                    sendJson(response, 200, await pickFilesystemDirectory(state, { cwd: repositoryPath, picker: directoryPicker }));
+                }
+                finally {
+                    activeDirectoryPick = false;
+                }
+                return;
+            }
             if (request.method === "POST" && pathname === "/api/filesystem/grants") {
                 const body = await readJson(request);
                 sendJson(response, 201, createFilesystemBrowseGrant(body, state, { cwd: repositoryPath }));
@@ -2994,6 +3010,73 @@ export function tryCreateFilesystemBrowseGrant(request, state, options = {}) {
     state.filesystemCapabilities[token] = capability;
     return ok({ capability });
 }
+export async function pickFilesystemDirectory(state, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const picker = options.picker ?? openNativeDirectoryPicker;
+    const picked = await picker({ cwd });
+    if (picked.status !== "selected") {
+        return picked;
+    }
+    const grant = createFilesystemBrowseGrant({ path: picked.path }, state, { cwd });
+    return {
+        status: "selected",
+        capability: grant.capability,
+        entry: filesystemBrowseEntryForPath(grant.capability.path, grant.capability.rootId)
+    };
+}
+export async function openNativeDirectoryPicker(_options) {
+    if (process.platform === "darwin") {
+        return runDirectoryPickerCommand("osascript", [
+            "-e",
+            "POSIX path of (choose folder with prompt \"Choose a project folder for Hunsu Studio\")"
+        ], {
+            cancelPatterns: [/User canceled/i, /-128/]
+        });
+    }
+    if (process.platform === "win32") {
+        return runDirectoryPickerCommand("powershell.exe", [
+            "-NoProfile",
+            "-STA",
+            "-Command",
+            [
+                "Add-Type -AssemblyName System.Windows.Forms;",
+                "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog;",
+                "$dialog.Description = 'Choose a project folder for Hunsu Studio';",
+                "$dialog.ShowNewFolderButton = $true;",
+                "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
+                "  [Console]::Out.WriteLine($dialog.SelectedPath);",
+                "  exit 0;",
+                "}",
+                "exit 2;"
+            ].join(" ")
+        ], {
+            cancelCodes: [2]
+        });
+    }
+    const zenity = await runDirectoryPickerCommand("zenity", [
+        "--file-selection",
+        "--directory",
+        "--title=Choose a project folder for Hunsu Studio"
+    ], {
+        cancelCodes: [1],
+        unavailablePatterns: [/cannot open display/i, /no display/i]
+    });
+    if (zenity.status !== "unavailable") {
+        return zenity;
+    }
+    const kdialog = await runDirectoryPickerCommand("kdialog", [
+        "--title",
+        "Choose a project folder for Hunsu Studio",
+        "--getexistingdirectory"
+    ], {
+        cancelCodes: [1],
+        unavailablePatterns: [/cannot connect/i, /no display/i]
+    });
+    if (kdialog.status !== "unavailable") {
+        return kdialog;
+    }
+    return { status: "unavailable", reason: "No supported native folder picker is available in this environment." };
+}
 function resolveRoadmapOpenRequestPath(request, state) {
     if (!request.browseToken) {
         return request;
@@ -3031,6 +3114,39 @@ function browseRootLabel(path) {
     }
     return basename(path) || path;
 }
+async function runDirectoryPickerCommand(command, args, options = {}) {
+    try {
+        const { stdout } = await execFileAsync(command, args);
+        const selectedPath = stdout.trim();
+        return selectedPath ? { status: "selected", path: selectedPath } : { status: "cancelled" };
+    }
+    catch (error) {
+        const pickerError = error;
+        const output = `${pickerError.stdout ?? ""}\n${pickerError.stderr ?? ""}\n${pickerError.message}`;
+        if (pickerError.code === "ENOENT" || options.unavailablePatterns?.some(pattern => pattern.test(output))) {
+            return { status: "unavailable", reason: `${command} is not available.` };
+        }
+        if (typeof pickerError.code === "number" && options.cancelCodes?.includes(pickerError.code)) {
+            return { status: "cancelled" };
+        }
+        if (options.cancelPatterns?.some(pattern => pattern.test(output))) {
+            return { status: "cancelled" };
+        }
+        return { status: "unavailable", reason: output.trim() || `${command} failed to open a folder picker.` };
+    }
+}
+function filesystemBrowseEntryForPath(path, rootId) {
+    const entryPath = String(path);
+    return {
+        kind: "directory",
+        name: basename(entryPath) || entryPath,
+        path: entryPath,
+        rootId,
+        type: "directory",
+        isGitRepository: existsSync(join(entryPath, ".git")),
+        isRoadmap: hasBrowseVisibleHunsuRuntimeFiles(entryPath)
+    };
+}
 function hashText(value) {
     return hashHex(createHash("sha256").update(value));
 }
@@ -3082,7 +3198,12 @@ function canonicalizeGrantTargetPath(path, roots) {
     }
 }
 function isAllowedBrowsePath(path, roots) {
-    return roots.some(root => path === root || path.startsWith(`${root}/`));
+    const normalizedPath = normalize(path);
+    return roots.some(root => {
+        const normalizedRoot = normalize(root);
+        const childPath = relative(normalizedRoot, normalizedPath);
+        return childPath === "" || (!childPath.startsWith("..") && !isAbsolute(childPath));
+    });
 }
 function shouldHideBrowseEntry(name) {
     return name === "node_modules"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunsu/bridge",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "description": "Hunsu Bridge localhost runtime and Studio API server.",
   "license": "Apache-2.0",
@@ -29,8 +29,8 @@
   "dependencies": {
     "@hunsu/codex-runner": "0.1.1",
     "@hunsu/core": "0.1.1",
-    "@hunsu/protocol": "0.1.1",
     "@hunsu/protocol-registry": "0.1.1",
+    "@hunsu/protocol": "0.1.1",
     "@hunsu/config": "0.1.1"
   },
   "scripts": {

package/src/index.ts

@@ -582,6 +582,7 @@ export type StudioServerOptions = {
   roadmapRegistryPath?: string;
   runtimeConfig?: BridgeRuntimeConfig;
   security?: StudioServerSecurityOptions;
+  directoryPicker?: NativeDirectoryPicker;
 };
 
 export type StudioCommandResult = {
@@ -687,6 +688,22 @@ export type FilesystemGrantResult = {
   capability: FilesystemBrowseCapability;
 };
 
+export type NativeDirectoryPickerOptions = {
+  cwd: string;
+};
+
+export type NativeDirectoryPickerResult =
+  | { status: "selected"; path: string }
+  | { status: "cancelled" }
+  | { status: "unavailable"; reason: string };
+
+export type NativeDirectoryPicker = (options: NativeDirectoryPickerOptions) => Promise<NativeDirectoryPickerResult>;
+
+export type FilesystemDirectoryPickResult =
+  | { status: "selected"; capability: FilesystemBrowseCapability; entry: FilesystemBrowseEntry }
+  | { status: "cancelled" }
+  | { status: "unavailable"; reason: string };
+
 export type MoveFileNode =
   | { kind: "directory"; name: string; path: string }
   | { kind: "textFile"; name: string; path: string; size: number }
@@ -1170,7 +1187,7 @@ function createStudioServerSecurity(options: StudioServerSecurityOptions | undef
   };
 }
 
-function evaluateStudioRequestSecurity(request: IncomingMessage, url: URL, security: StudioServerSecurity): StudioRequestSecurity {
+function evaluateStudioRequestSecurity(request: IncomingMessage, url: URL, security: StudioServerSecurity, options: { skipAuth?: boolean } = {}): StudioRequestSecurity {
   const origin = requestHeader(request, "origin");
   const corsHeaders = corsHeadersForOrigin(origin, security);
   if (origin && corsHeaders === undefined) {
@@ -1190,7 +1207,7 @@ function evaluateStudioRequestSecurity(request: IncomingMessage, url: URL, secur
     };
   }
   const headers = corsHeaders ?? baseCorsHeaders();
-  if (security.authToken && !isPublicBridgeRequest(url) && !hasValidBridgeApiToken(request, url, security.authToken)) {
+  if (!options.skipAuth && security.authToken && !isPublicBridgeRequest(url) && !hasValidBridgeApiToken(request, url, security.authToken)) {
     return {
       allowed: false,
       status: 401,
@@ -1695,12 +1712,14 @@ export function createStudioServer(options: StudioServerOptions = {}) {
   const runner = options.runner ?? createConfiguredRunner(runtimeConfig);
   const actionRunner = options.actionRunner;
   const security = createStudioServerSecurity(options.security, runtimeConfig);
+  const directoryPicker = options.directoryPicker ?? openNativeDirectoryPicker;
+  let activeDirectoryPick = false;
 
   return createServer(async (request, response) => {
     try {
       const url = new URL(request.url ?? "/", "http://localhost");
       const pathname = url.pathname;
-      const requestSecurity = evaluateStudioRequestSecurity(request, url, security);
+      const requestSecurity = evaluateStudioRequestSecurity(request, url, security, { skipAuth: request.method === "OPTIONS" });
       responseSecurityHeaders.set(response, requestSecurity.corsHeaders);
       if (request.method === "OPTIONS") {
         sendJson(response, requestSecurity.allowed ? 204 : requestSecurity.status ?? 403, requestSecurity.allowed ? {} : { error: requestSecurity.error ?? "Origin is not allowed." });
@@ -1739,6 +1758,20 @@ export function createStudioServer(options: StudioServerOptions = {}) {
         return;
       }
 
+      if (request.method === "POST" && pathname === "/api/filesystem/pick-directory") {
+        if (activeDirectoryPick) {
+          sendJson(response, 409, { status: "unavailable", reason: "A folder picker is already open." });
+          return;
+        }
+        activeDirectoryPick = true;
+        try {
+          sendJson(response, 200, await pickFilesystemDirectory(state, { cwd: repositoryPath, picker: directoryPicker }));
+        } finally {
+          activeDirectoryPick = false;
+        }
+        return;
+      }
+
       if (request.method === "POST" && pathname === "/api/filesystem/grants") {
         const body = await readJson<FilesystemGrantRequest>(request);
         sendJson(response, 201, createFilesystemBrowseGrant(body, state, { cwd: repositoryPath }));
@@ -4427,6 +4460,82 @@ export function tryCreateFilesystemBrowseGrant(
   return ok({ capability });
 }
 
+export async function pickFilesystemDirectory(
+  state: StudioServerState,
+  options: { cwd?: string; picker?: NativeDirectoryPicker } = {}
+): Promise<FilesystemDirectoryPickResult> {
+  const cwd = options.cwd ?? process.cwd();
+  const picker = options.picker ?? openNativeDirectoryPicker;
+  const picked = await picker({ cwd });
+  if (picked.status !== "selected") {
+    return picked;
+  }
+  const grant = createFilesystemBrowseGrant({ path: picked.path }, state, { cwd });
+  return {
+    status: "selected",
+    capability: grant.capability,
+    entry: filesystemBrowseEntryForPath(grant.capability.path, grant.capability.rootId)
+  };
+}
+
+export async function openNativeDirectoryPicker(_options: NativeDirectoryPickerOptions): Promise<NativeDirectoryPickerResult> {
+  if (process.platform === "darwin") {
+    return runDirectoryPickerCommand("osascript", [
+      "-e",
+      "POSIX path of (choose folder with prompt \"Choose a project folder for Hunsu Studio\")"
+    ], {
+      cancelPatterns: [/User canceled/i, /-128/]
+    });
+  }
+
+  if (process.platform === "win32") {
+    return runDirectoryPickerCommand("powershell.exe", [
+      "-NoProfile",
+      "-STA",
+      "-Command",
+      [
+        "Add-Type -AssemblyName System.Windows.Forms;",
+        "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog;",
+        "$dialog.Description = 'Choose a project folder for Hunsu Studio';",
+        "$dialog.ShowNewFolderButton = $true;",
+        "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
+        "  [Console]::Out.WriteLine($dialog.SelectedPath);",
+        "  exit 0;",
+        "}",
+        "exit 2;"
+      ].join(" ")
+    ], {
+      cancelCodes: [2]
+    });
+  }
+
+  const zenity = await runDirectoryPickerCommand("zenity", [
+    "--file-selection",
+    "--directory",
+    "--title=Choose a project folder for Hunsu Studio"
+  ], {
+    cancelCodes: [1],
+    unavailablePatterns: [/cannot open display/i, /no display/i]
+  });
+  if (zenity.status !== "unavailable") {
+    return zenity;
+  }
+
+  const kdialog = await runDirectoryPickerCommand("kdialog", [
+    "--title",
+    "Choose a project folder for Hunsu Studio",
+    "--getexistingdirectory"
+  ], {
+    cancelCodes: [1],
+    unavailablePatterns: [/cannot connect/i, /no display/i]
+  });
+  if (kdialog.status !== "unavailable") {
+    return kdialog;
+  }
+
+  return { status: "unavailable", reason: "No supported native folder picker is available in this environment." };
+}
+
 function resolveRoadmapOpenRequestPath<T extends RoadmapOpenRequest>(request: T, state: StudioServerState): T {
   if (!request.browseToken) {
     return request;
@@ -4469,6 +4578,44 @@ function browseRootLabel(path: string): string {
   return basename(path) || path;
 }
 
+async function runDirectoryPickerCommand(
+  command: string,
+  args: string[],
+  options: { cancelCodes?: number[]; cancelPatterns?: RegExp[]; unavailablePatterns?: RegExp[] } = {}
+): Promise<NativeDirectoryPickerResult> {
+  try {
+    const { stdout } = await execFileAsync(command, args);
+    const selectedPath = stdout.trim();
+    return selectedPath ? { status: "selected", path: selectedPath } : { status: "cancelled" };
+  } catch (error) {
+    const pickerError = error as Error & { code?: string | number; stderr?: string; stdout?: string };
+    const output = `${pickerError.stdout ?? ""}\n${pickerError.stderr ?? ""}\n${pickerError.message}`;
+    if (pickerError.code === "ENOENT" || options.unavailablePatterns?.some(pattern => pattern.test(output))) {
+      return { status: "unavailable", reason: `${command} is not available.` };
+    }
+    if (typeof pickerError.code === "number" && options.cancelCodes?.includes(pickerError.code)) {
+      return { status: "cancelled" };
+    }
+    if (options.cancelPatterns?.some(pattern => pattern.test(output))) {
+      return { status: "cancelled" };
+    }
+    return { status: "unavailable", reason: output.trim() || `${command} failed to open a folder picker.` };
+  }
+}
+
+function filesystemBrowseEntryForPath(path: CanonicalLocalPath, rootId: BrowseRootId): FilesystemBrowseEntry {
+  const entryPath = String(path);
+  return {
+    kind: "directory",
+    name: basename(entryPath) || entryPath,
+    path: entryPath,
+    rootId,
+    type: "directory",
+    isGitRepository: existsSync(join(entryPath, ".git")),
+    isRoadmap: hasBrowseVisibleHunsuRuntimeFiles(entryPath)
+  };
+}
+
 function hashText(value: string): string {
   return hashHex(createHash("sha256").update(value));
 }
@@ -4523,7 +4670,12 @@ function canonicalizeGrantTargetPath(path: string, roots: string[]): string | un
 }
 
 function isAllowedBrowsePath(path: string, roots: string[]): boolean {
-  return roots.some(root => path === root || path.startsWith(`${root}/`));
+  const normalizedPath = normalize(path);
+  return roots.some(root => {
+    const normalizedRoot = normalize(root);
+    const childPath = relative(normalizedRoot, normalizedPath);
+    return childPath === "" || (!childPath.startsWith("..") && !isAbsolute(childPath));
+  });
 }
 
 function shouldHideBrowseEntry(name: string): boolean {