tmex-cli 0.9.2 → 0.10.0

package/dist/runtime/server.js

@@ -22550,7 +22550,7 @@ loadEnv();
 
 // src/runtime/server.ts
 import { existsSync as existsSync5 } from "fs";
-import { extname, join as join4, normalize, resolve as resolve4, sep } from "path";
+import { extname as extname2, join as join6, normalize, resolve as resolve4, sep } from "path";
 
 // ../../apps/gateway/src/crypto/errors.ts
 function contextLabel(context) {
@@ -22807,6 +22807,29 @@ var I18N_RESOURCES = {
           clearKeyConfirm: "Clear this API key? You will need to enter it again.",
           loadFailed: "Failed to load search settings",
           saveFailed: "Failed to save search settings"
+        },
+        files: {
+          title: "Files",
+          description: "Per-device directories browsable in the Files tab. Local devices read directly; SSH devices use rsync.",
+          addRoot: "Add directory",
+          roots: "Directories",
+          empty: "No directories configured",
+          missing: "Device missing",
+          modalAddTitle: "Add directory",
+          modalEditTitle: "Edit directory",
+          device: "Device",
+          devicePlaceholder: "Select a device",
+          noDevices: "No devices yet \u2014 add one first",
+          path: "Path",
+          pathPlaceholder: "/absolute/path/to/directory",
+          pathHint: "Absolute path on the selected device.",
+          enabled: "Enabled",
+          addFailed: "Failed to add directory",
+          updateFailed: "Failed to update directory",
+          deleteFailed: "Failed to remove directory",
+          toggleFailed: "Failed to update directory",
+          deleteTitle: "Remove directory?",
+          deleteDesc: 'Remove "{{path}}" from the whitelist? Files under it will no longer be accessible.'
         }
       },
       telegram: {
@@ -22985,7 +23008,14 @@ Time: {{time}}`,
         watchFireModeInvalid: "Fire mode must be once or repeat",
         watchCooldownInvalid: "Cooldown seconds must be an integer >= 0",
         watchAssistDescriptionRequired: "Please describe what to match",
-        watchAssistModelUnavailable: "Model call failed: {{detail}}"
+        watchAssistModelUnavailable: "Model call failed: {{detail}}",
+        fileRootInvalid: "Path must be an absolute, existing directory",
+        fileOutsideRoots: "Path is outside the allowed directories",
+        fileNotADirectory: "Not a directory",
+        fileTooLarge: "File is too large",
+        fileBinary: "Binary files are not supported",
+        fileRootDeviceInvalid: "Invalid or unknown device",
+        fileRootDuplicate: "This directory is already added for the device"
       },
       notification: {
         clickToJump: "Click to jump to corresponding pane",
@@ -23275,6 +23305,54 @@ Time: {{time}}`,
       validation: {
         deviceNameRequired: "Device name is required",
         hostRequired: "Host is required for SSH devices"
+      },
+      files: {
+        title: "Files",
+        refresh: "Refresh file list",
+        noRoots: "No accessible directories. Add one in Settings \u2192 Files.",
+        emptyDir: "Empty",
+        truncated: "Too many items \u2014 list truncated",
+        download: "Download",
+        error: {
+          invalid: "Invalid request",
+          outside_roots: "Path is outside the allowed directory",
+          not_found: "No longer exists",
+          not_a_directory: "Not a directory",
+          is_directory: "This is a directory",
+          too_large: "File is too large to preview",
+          binary: "Binary file cannot be previewed",
+          permission_denied: "Permission denied",
+          device_not_found: "Device not found",
+          root_not_found: "Directory entry not found",
+          root_disabled: "This directory is disabled",
+          connection_failed: "Failed to connect to the device",
+          auth_unsupported: "Device auth method unsupported for files (use key or ssh-agent)",
+          rsync_missing_local: "rsync is not installed on the server",
+          rsync_missing_remote: "rsync is not installed on the remote device",
+          timeout: "Timed out",
+          unknown: "Failed to load"
+        },
+        retry: "Retry (collapse then expand)",
+        install: {
+          button: "Install rsync",
+          scopeLocal: "server",
+          scopeRemote: "remote",
+          connectFailed: "Failed to connect to the device",
+          windowFailed: "Failed to create a window",
+          prompt: "rsync is not installed on {{device}} ({{scope}}). Please install rsync using the appropriate command for this system (e.g. `brew install rsync`, `sudo apt-get install -y rsync`, or `sudo yum install -y rsync`), then reply once it is done."
+        }
+      },
+      file: {
+        invalidRef: "Invalid file reference",
+        notFound: "File no longer exists",
+        accessDenied: "Access denied",
+        loadFailed: "Failed to load file",
+        isDirectory: "This is a directory",
+        notPreviewable: "Preview is not available for this file type",
+        tooLarge: "File is too large to preview",
+        binary: "Binary file cannot be previewed",
+        download: "Download",
+        openRaw: "Open raw"
       }
     }
   },
@@ -23508,6 +23586,29 @@ Time: {{time}}`,
           clearKeyConfirm: "\u786E\u5B9A\u8981\u6E05\u9664\u6B64 API Key \u5417\uFF1F\u6E05\u9664\u540E\u9700\u8981\u91CD\u65B0\u586B\u5199\u3002",
           loadFailed: "\u52A0\u8F7D\u641C\u7D22\u8BBE\u7F6E\u5931\u8D25",
           saveFailed: "\u4FDD\u5B58\u641C\u7D22\u8BBE\u7F6E\u5931\u8D25"
+        },
+        files: {
+          title: "\u6587\u4EF6",
+          description: "\u914D\u7F6E\u5404\u8BBE\u5907\u4E0B\u53EF\u5728\u300C\u6587\u4EF6\u300D\u6807\u7B7E\u9875\u6D4F\u89C8\u7684\u76EE\u5F55\u3002\u672C\u5730\u8BBE\u5907\u76F4\u63A5\u8BFB\u53D6\uFF0CSSH \u8BBE\u5907\u8D70 rsync\u3002",
+          addRoot: "\u6DFB\u52A0\u76EE\u5F55",
+          roots: "\u76EE\u5F55",
+          empty: "\u5C1A\u672A\u914D\u7F6E\u4EFB\u4F55\u76EE\u5F55",
+          missing: "\u8BBE\u5907\u5DF2\u5931\u6548",
+          modalAddTitle: "\u6DFB\u52A0\u76EE\u5F55",
+          modalEditTitle: "\u7F16\u8F91\u76EE\u5F55",
+          device: "\u8BBE\u5907",
+          devicePlaceholder: "\u9009\u62E9\u8BBE\u5907",
+          noDevices: "\u8FD8\u6CA1\u6709\u8BBE\u5907\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BBE\u5907",
+          path: "\u8DEF\u5F84",
+          pathPlaceholder: "/\u7EDD\u5BF9\u8DEF\u5F84/\u5230/\u76EE\u5F55",
+          pathHint: "\u6240\u9009\u8BBE\u5907\u4E0A\u7684\u7EDD\u5BF9\u8DEF\u5F84\u3002",
+          enabled: "\u542F\u7528",
+          addFailed: "\u6DFB\u52A0\u76EE\u5F55\u5931\u8D25",
+          updateFailed: "\u66F4\u65B0\u76EE\u5F55\u5931\u8D25",
+          deleteFailed: "\u79FB\u9664\u76EE\u5F55\u5931\u8D25",
+          toggleFailed: "\u66F4\u65B0\u76EE\u5F55\u5931\u8D25",
+          deleteTitle: "\u79FB\u9664\u76EE\u5F55\uFF1F",
+          deleteDesc: "\u5C06\u300C{{path}}\u300D\u79FB\u51FA\u767D\u540D\u5355\uFF1F\u8BE5\u76EE\u5F55\u4E0B\u7684\u6587\u4EF6\u5C06\u4E0D\u518D\u53EF\u8BBF\u95EE\u3002"
         }
       },
       telegram: {
@@ -23686,7 +23787,14 @@ Bot\uFF1A{{botName}}
         watchFireModeInvalid: "\u89E6\u53D1\u6A21\u5F0F\u5FC5\u987B\u662F once \u6216 repeat",
         watchCooldownInvalid: "\u51B7\u5374\u79D2\u6570\u5FC5\u987B\u662F\u4E0D\u5C0F\u4E8E 0 \u7684\u6574\u6570",
         watchAssistDescriptionRequired: "\u8BF7\u63CF\u8FF0\u8981\u5339\u914D\u7684\u5185\u5BB9",
-        watchAssistModelUnavailable: "\u6A21\u578B\u8C03\u7528\u5931\u8D25\uFF1A{{detail}}"
+        watchAssistModelUnavailable: "\u6A21\u578B\u8C03\u7528\u5931\u8D25\uFF1A{{detail}}",
+        fileRootInvalid: "\u8DEF\u5F84\u5FC5\u987B\u662F\u5DF2\u5B58\u5728\u7684\u7EDD\u5BF9\u76EE\u5F55",
+        fileOutsideRoots: "\u8DEF\u5F84\u4E0D\u5728\u5141\u8BB8\u7684\u76EE\u5F55\u8303\u56F4\u5185",
+        fileNotADirectory: "\u4E0D\u662F\u76EE\u5F55",
+        fileTooLarge: "\u6587\u4EF6\u8FC7\u5927",
+        fileBinary: "\u4E0D\u652F\u6301\u4E8C\u8FDB\u5236\u6587\u4EF6",
+        fileRootDeviceInvalid: "\u65E0\u6548\u6216\u672A\u77E5\u7684\u8BBE\u5907",
+        fileRootDuplicate: "\u8BE5\u8BBE\u5907\u4E0B\u5DF2\u6DFB\u52A0\u8FC7\u6B64\u76EE\u5F55"
       },
       notification: {
         clickToJump: "\u70B9\u51FB\u8DF3\u8F6C\u5230\u5BF9\u5E94 Pane",
@@ -23976,6 +24084,54 @@ Bot\uFF1A{{botName}}
       validation: {
         deviceNameRequired: "\u8BBE\u5907\u540D\u79F0\u4E3A\u5FC5\u586B\u9879",
         hostRequired: "SSH \u8BBE\u5907\u9700\u8981\u586B\u5199\u4E3B\u673A\u5730\u5740"
+      },
+      files: {
+        title: "\u6587\u4EF6",
+        refresh: "\u5237\u65B0\u6587\u4EF6\u5217\u8868",
+        noRoots: "\u6CA1\u6709\u53EF\u8BBF\u95EE\u7684\u76EE\u5F55\u3002\u8BF7\u5728\u300C\u8BBE\u7F6E \u2192 \u6587\u4EF6\u300D\u4E2D\u6DFB\u52A0\u3002",
+        emptyDir: "\u7A7A\u76EE\u5F55",
+        truncated: "\u6761\u76EE\u8FC7\u591A\uFF0C\u5217\u8868\u5DF2\u622A\u65AD",
+        download: "\u4E0B\u8F7D",
+        error: {
+          invalid: "\u65E0\u6548\u8BF7\u6C42",
+          outside_roots: "\u8DEF\u5F84\u8D85\u51FA\u5141\u8BB8\u7684\u76EE\u5F55\u8303\u56F4",
+          not_found: "\u5DF2\u4E0D\u5B58\u5728",
+          not_a_directory: "\u4E0D\u662F\u76EE\u5F55",
+          is_directory: "\u8FD9\u662F\u4E00\u4E2A\u76EE\u5F55",
+          too_large: "\u6587\u4EF6\u8FC7\u5927\uFF0C\u65E0\u6CD5\u9884\u89C8",
+          binary: "\u4E8C\u8FDB\u5236\u6587\u4EF6\u65E0\u6CD5\u9884\u89C8",
+          permission_denied: "\u65E0\u8BBF\u95EE\u6743\u9650",
+          device_not_found: "\u8BBE\u5907\u4E0D\u5B58\u5728",
+          root_not_found: "\u76EE\u5F55\u9879\u4E0D\u5B58\u5728",
+          root_disabled: "\u8BE5\u76EE\u5F55\u5DF2\u7981\u7528",
+          connection_failed: "\u8FDE\u63A5\u8BBE\u5907\u5931\u8D25",
+          auth_unsupported: "\u8BE5\u8BBE\u5907\u7684\u8BA4\u8BC1\u65B9\u5F0F\u4E0D\u652F\u6301\u6587\u4EF6\u8BBF\u95EE\uFF08\u8BF7\u7528\u5BC6\u94A5\u6216 ssh-agent\uFF09",
+          rsync_missing_local: "\u670D\u52A1\u5668\u4E0A\u672A\u5B89\u88C5 rsync",
+          rsync_missing_remote: "\u8FDC\u7A0B\u8BBE\u5907\u4E0A\u672A\u5B89\u88C5 rsync",
+          timeout: "\u5DF2\u8D85\u65F6",
+          unknown: "\u52A0\u8F7D\u5931\u8D25"
+        },
+        retry: "\u91CD\u8BD5\uFF08\u6536\u8D77\u540E\u518D\u5C55\u5F00\uFF09",
+        install: {
+          button: "\u5B89\u88C5 rsync",
+          scopeLocal: "\u670D\u52A1\u5668",
+          scopeRemote: "\u8FDC\u7A0B",
+          connectFailed: "\u8FDE\u63A5\u8BBE\u5907\u5931\u8D25",
+          windowFailed: "\u521B\u5EFA\u7A97\u53E3\u5931\u8D25",
+          prompt: "\u8BBE\u5907 {{device}}\uFF08{{scope}}\uFF09\u4E0A\u672A\u68C0\u6D4B\u5230 rsync\u3002\u8BF7\u6839\u636E\u7CFB\u7EDF\u9009\u62E9\u5408\u9002\u7684\u547D\u4EE4\u5B89\u88C5 rsync\uFF08\u4F8B\u5982 `brew install rsync`\u3001`sudo apt-get install -y rsync` \u6216 `sudo yum install -y rsync`\uFF09\uFF0C\u5B89\u88C5\u5B8C\u6210\u540E\u56DE\u590D\u6211\u3002"
+        }
+      },
+      file: {
+        invalidRef: "\u65E0\u6548\u7684\u6587\u4EF6\u5F15\u7528",
+        notFound: "\u6587\u4EF6\u5DF2\u4E0D\u5B58\u5728",
+        accessDenied: "\u65E0\u8BBF\u95EE\u6743\u9650",
+        loadFailed: "\u52A0\u8F7D\u6587\u4EF6\u5931\u8D25",
+        isDirectory: "\u8FD9\u662F\u4E00\u4E2A\u76EE\u5F55",
+        notPreviewable: "\u8BE5\u6587\u4EF6\u7C7B\u578B\u4E0D\u652F\u6301\u9884\u89C8",
+        tooLarge: "\u6587\u4EF6\u8FC7\u5927\uFF0C\u65E0\u6CD5\u9884\u89C8",
+        binary: "\u4E8C\u8FDB\u5236\u6587\u4EF6\u65E0\u6CD5\u9884\u89C8",
+        download: "\u4E0B\u8F7D",
+        openRaw: "\u6253\u5F00\u539F\u59CB\u6587\u4EF6"
       }
     }
   },
@@ -24209,6 +24365,29 @@ Bot\uFF1A{{botName}}
           clearKeyConfirm: "\u3053\u306E API \u30AD\u30FC\u3092\u30AF\u30EA\u30A2\u3057\u307E\u3059\u304B\uFF1F\u518D\u5EA6\u5165\u529B\u304C\u5FC5\u8981\u306B\u306A\u308A\u307E\u3059\u3002",
           loadFailed: "\u691C\u7D22\u8A2D\u5B9A\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
           saveFailed: "\u691C\u7D22\u8A2D\u5B9A\u306E\u4FDD\u5B58\u306B\u5931\u6557\u3057\u307E\u3057\u305F"
+        },
+        files: {
+          title: "\u30D5\u30A1\u30A4\u30EB",
+          description: "\u300C\u30D5\u30A1\u30A4\u30EB\u300D\u30BF\u30D6\u3067\u95B2\u89A7\u3067\u304D\u308B\u30C7\u30D0\u30A4\u30B9\u3054\u3068\u306E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u8A2D\u5B9A\u3057\u307E\u3059\u3002\u30ED\u30FC\u30AB\u30EB\u306F\u76F4\u63A5\u8AAD\u307F\u53D6\u308A\u3001SSH \u306F rsync \u3092\u4F7F\u7528\u3002",
+          addRoot: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u8FFD\u52A0",
+          roots: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA",
+          empty: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u304C\u8A2D\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+          missing: "\u30C7\u30D0\u30A4\u30B9\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+          modalAddTitle: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u8FFD\u52A0",
+          modalEditTitle: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u7DE8\u96C6",
+          device: "\u30C7\u30D0\u30A4\u30B9",
+          devicePlaceholder: "\u30C7\u30D0\u30A4\u30B9\u3092\u9078\u629E",
+          noDevices: "\u30C7\u30D0\u30A4\u30B9\u304C\u3042\u308A\u307E\u305B\u3093\u3002\u5148\u306B\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044",
+          path: "\u30D1\u30B9",
+          pathPlaceholder: "/\u7D76\u5BFE\u30D1\u30B9/\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA",
+          pathHint: "\u9078\u629E\u3057\u305F\u30C7\u30D0\u30A4\u30B9\u4E0A\u306E\u7D76\u5BFE\u30D1\u30B9\u3002",
+          enabled: "\u6709\u52B9",
+          addFailed: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306E\u8FFD\u52A0\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+          updateFailed: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306E\u66F4\u65B0\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+          deleteFailed: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306E\u524A\u9664\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+          toggleFailed: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306E\u66F4\u65B0\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+          deleteTitle: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u524A\u9664\u3057\u307E\u3059\u304B\uFF1F",
+          deleteDesc: "\u300C{{path}}\u300D\u3092\u30DB\u30EF\u30A4\u30C8\u30EA\u30B9\u30C8\u304B\u3089\u524A\u9664\u3057\u307E\u3059\u304B\uFF1F\u914D\u4E0B\u306E\u30D5\u30A1\u30A4\u30EB\u306B\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u306A\u304F\u306A\u308A\u307E\u3059\u3002"
         }
       },
       telegram: {
@@ -24387,7 +24566,14 @@ Bot\uFF1A{{botName}}
         watchFireModeInvalid: "\u767A\u706B\u30E2\u30FC\u30C9\u306F once \u307E\u305F\u306F repeat \u3067\u3059",
         watchCooldownInvalid: "\u30AF\u30FC\u30EB\u30C0\u30A6\u30F3\u79D2\u6570\u306F 0 \u4EE5\u4E0A\u306E\u6574\u6570\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044",
         watchAssistDescriptionRequired: "\u30DE\u30C3\u30C1\u3055\u305B\u305F\u3044\u5185\u5BB9\u3092\u8A18\u8FF0\u3057\u3066\u304F\u3060\u3055\u3044",
-        watchAssistModelUnavailable: "\u30E2\u30C7\u30EB\u547C\u3073\u51FA\u3057\u306B\u5931\u6557\u3057\u307E\u3057\u305F\uFF1A{{detail}}"
+        watchAssistModelUnavailable: "\u30E2\u30C7\u30EB\u547C\u3073\u51FA\u3057\u306B\u5931\u6557\u3057\u307E\u3057\u305F\uFF1A{{detail}}",
+        fileRootInvalid: "\u7D76\u5BFE\u30D1\u30B9\u304B\u3064\u65E2\u5B58\u306E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044",
+        fileOutsideRoots: "\u8A31\u53EF\u3055\u308C\u305F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306E\u7BC4\u56F2\u5916\u3067\u3059",
+        fileNotADirectory: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3067\u306F\u3042\u308A\u307E\u305B\u3093",
+        fileTooLarge: "\u30D5\u30A1\u30A4\u30EB\u304C\u5927\u304D\u3059\u304E\u307E\u3059",
+        fileBinary: "\u30D0\u30A4\u30CA\u30EA\u30D5\u30A1\u30A4\u30EB\u306F\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+        fileRootDeviceInvalid: "\u7121\u52B9\u307E\u305F\u306F\u4E0D\u660E\u306A\u30C7\u30D0\u30A4\u30B9",
+        fileRootDuplicate: "\u3053\u306E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306F\u3053\u306E\u30C7\u30D0\u30A4\u30B9\u306B\u65E2\u306B\u8FFD\u52A0\u3055\u308C\u3066\u3044\u307E\u3059"
       },
       notification: {
         clickToJump: "\u5BFE\u5FDC\u3059\u308B\u30DA\u30A4\u30F3\u306B\u30B8\u30E3\u30F3\u30D7",
@@ -24677,6 +24863,54 @@ Bot\uFF1A{{botName}}
       validation: {
         deviceNameRequired: "\u30C7\u30D0\u30A4\u30B9\u540D\u306F\u5FC5\u9808\u3067\u3059",
         hostRequired: "SSH \u30C7\u30D0\u30A4\u30B9\u306B\u306F\u30DB\u30B9\u30C8\u30A2\u30C9\u30EC\u30B9\u304C\u5FC5\u8981\u3067\u3059"
+      },
+      files: {
+        title: "\u30D5\u30A1\u30A4\u30EB",
+        refresh: "\u30D5\u30A1\u30A4\u30EB\u4E00\u89A7\u3092\u66F4\u65B0",
+        noRoots: "\u30A2\u30AF\u30BB\u30B9\u53EF\u80FD\u306A\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u304C\u3042\u308A\u307E\u305B\u3093\u3002\u300C\u8A2D\u5B9A \u2192 \u30D5\u30A1\u30A4\u30EB\u300D\u3067\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        emptyDir: "\u7A7A\u306E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA",
+        truncated: "\u9805\u76EE\u304C\u591A\u3059\u304E\u308B\u305F\u3081\u4E00\u89A7\u3092\u7701\u7565\u3057\u307E\u3057\u305F",
+        download: "\u30C0\u30A6\u30F3\u30ED\u30FC\u30C9",
+        error: {
+          invalid: "\u4E0D\u6B63\u306A\u30EA\u30AF\u30A8\u30B9\u30C8",
+          outside_roots: "\u8A31\u53EF\u3055\u308C\u305F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306E\u7BC4\u56F2\u5916\u3067\u3059",
+          not_found: "\u3059\u3067\u306B\u5B58\u5728\u3057\u307E\u305B\u3093",
+          not_a_directory: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3067\u306F\u3042\u308A\u307E\u305B\u3093",
+          is_directory: "\u3053\u308C\u306F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3067\u3059",
+          too_large: "\u30D5\u30A1\u30A4\u30EB\u304C\u5927\u304D\u3059\u304E\u3066\u30D7\u30EC\u30D3\u30E5\u30FC\u3067\u304D\u307E\u305B\u3093",
+          binary: "\u30D0\u30A4\u30CA\u30EA\u30D5\u30A1\u30A4\u30EB\u306F\u30D7\u30EC\u30D3\u30E5\u30FC\u3067\u304D\u307E\u305B\u3093",
+          permission_denied: "\u30A2\u30AF\u30BB\u30B9\u304C\u62D2\u5426\u3055\u308C\u307E\u3057\u305F",
+          device_not_found: "\u30C7\u30D0\u30A4\u30B9\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+          root_not_found: "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u9805\u76EE\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+          root_disabled: "\u3053\u306E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306F\u7121\u52B9\u3067\u3059",
+          connection_failed: "\u30C7\u30D0\u30A4\u30B9\u3078\u306E\u63A5\u7D9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+          auth_unsupported: "\u3053\u306E\u30C7\u30D0\u30A4\u30B9\u306E\u8A8D\u8A3C\u65B9\u5F0F\u306F\u30D5\u30A1\u30A4\u30EB\u30A2\u30AF\u30BB\u30B9\u306B\u975E\u5BFE\u5FDC\u3067\u3059\uFF08\u9375\u304B ssh-agent \u3092\u4F7F\u7528\uFF09",
+          rsync_missing_local: "\u30B5\u30FC\u30D0\u30FC\u306B rsync \u304C\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+          rsync_missing_remote: "\u30EA\u30E2\u30FC\u30C8\u30C7\u30D0\u30A4\u30B9\u306B rsync \u304C\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+          timeout: "\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8\u3057\u307E\u3057\u305F",
+          unknown: "\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F"
+        },
+        retry: "\u518D\u8A66\u884C\uFF08\u6298\u308A\u305F\u305F\u3093\u3067\u518D\u5C55\u958B\uFF09",
+        install: {
+          button: "rsync \u3092\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB",
+          scopeLocal: "\u30B5\u30FC\u30D0\u30FC",
+          scopeRemote: "\u30EA\u30E2\u30FC\u30C8",
+          connectFailed: "\u30C7\u30D0\u30A4\u30B9\u3078\u306E\u63A5\u7D9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+          windowFailed: "\u30A6\u30A3\u30F3\u30C9\u30A6\u306E\u4F5C\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+          prompt: "{{device}}\uFF08{{scope}}\uFF09\u306B rsync \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002\u30B7\u30B9\u30C6\u30E0\u306B\u5408\u308F\u305B\u305F\u65B9\u6CD5\u3067 rsync \u3092\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3057\uFF08\u4F8B: `brew install rsync`\u3001`sudo apt-get install -y rsync`\u3001`sudo yum install -y rsync`\uFF09\u3001\u5B8C\u4E86\u3057\u305F\u3089\u8FD4\u4FE1\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        }
+      },
+      file: {
+        invalidRef: "\u7121\u52B9\u306A\u30D5\u30A1\u30A4\u30EB\u53C2\u7167\u3067\u3059",
+        notFound: "\u30D5\u30A1\u30A4\u30EB\u306F\u5B58\u5728\u3057\u307E\u305B\u3093",
+        accessDenied: "\u30A2\u30AF\u30BB\u30B9\u304C\u62D2\u5426\u3055\u308C\u307E\u3057\u305F",
+        loadFailed: "\u30D5\u30A1\u30A4\u30EB\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        isDirectory: "\u3053\u308C\u306F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3067\u3059",
+        notPreviewable: "\u3053\u306E\u30D5\u30A1\u30A4\u30EB\u5F62\u5F0F\u306F\u30D7\u30EC\u30D3\u30E5\u30FC\u3067\u304D\u307E\u305B\u3093",
+        tooLarge: "\u30D5\u30A1\u30A4\u30EB\u304C\u5927\u304D\u3059\u304E\u3066\u30D7\u30EC\u30D3\u30E5\u30FC\u3067\u304D\u307E\u305B\u3093",
+        binary: "\u30D0\u30A4\u30CA\u30EA\u30D5\u30A1\u30A4\u30EB\u306F\u30D7\u30EC\u30D3\u30E5\u30FC\u3067\u304D\u307E\u305B\u3093",
+        download: "\u30C0\u30A6\u30F3\u30ED\u30FC\u30C9",
+        openRaw: "\u5143\u30D5\u30A1\u30A4\u30EB\u3092\u958B\u304F"
       }
     }
   }
@@ -32196,6 +32430,7 @@ __export(exports_schema2, {
   telegramBotChats: () => telegramBotChats,
   siteSettings: () => siteSettings,
   llmProviders: () => llmProviders,
+  fileRoots: () => fileRoots,
   devices: () => devices,
   deviceTreeOrder: () => deviceTreeOrder,
   deviceRuntimeStatus: () => deviceRuntimeStatus,
@@ -32394,6 +32629,14 @@ var deviceTreeOrder = sqliteTable("device_tree_order", {
   panes: text("panes", { mode: "json" }).$type().notNull().default({}),
   updatedAt: text("updated_at").notNull()
 });
+var fileRoots = sqliteTable("file_roots", {
+  id: text("id").primaryKey(),
+  deviceId: text("device_id").notNull().references(() => devices.id, { onDelete: "cascade" }),
+  path: text("path").notNull(),
+  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  sortOrder: integer("sort_order").notNull().default(0),
+  createdAt: text("created_at").notNull()
+}, (table) => [unique("file_roots_device_path_unique").on(table.deviceId, table.path)]);
 var telegramBotChats = sqliteTable("telegram_bot_chats", {
   id: text("id").primaryKey(),
   botId: text("bot_id").notNull().references(() => telegramBots.id, { onDelete: "cascade" }),
@@ -33154,7 +33397,7 @@ function decideAgentConfirmation(id, decision) {
   return updated ?? null;
 }
 
-// ../../node_modules/.bun/gramio@0.4.12+cb432ad7c9c526f6/node_modules/gramio/dist/index.js
+// ../../node_modules/.bun/gramio@0.4.12+7be50f8974dcb86c/node_modules/gramio/dist/index.js
 var exports_dist5 = {};
 __export(exports_dist5, {
   webhookHandler: () => webhookHandler,
@@ -53088,7 +53331,7 @@ class MediaUpload {
     return new File([text2], filename);
   }
 }
-// ../../node_modules/.bun/@gramio+format@0.3.4/node_modules/@gramio/format/dist/index.js
+// ../../node_modules/.bun/@gramio+format@0.3.4+32af5fe46ea567aa/node_modules/@gramio/format/dist/index.js
 var exports_dist3 = {};
 __export(exports_dist3, {
   underline: () => underline,
@@ -53553,10 +53796,10 @@ function formatSaveIndents(stringParts, ...strings) {
   return processRawFormat([...stringParts], strings);
 }
 
-// ../../node_modules/.bun/gramio@0.4.12+cb432ad7c9c526f6/node_modules/gramio/dist/index.js
+// ../../node_modules/.bun/gramio@0.4.12+7be50f8974dcb86c/node_modules/gramio/dist/index.js
 var import_debug2 = __toESM(require_src2(), 1);
 
-// ../../node_modules/.bun/gramio@0.4.12+cb432ad7c9c526f6/node_modules/gramio/dist/utils-CJfJNxc_.js
+// ../../node_modules/.bun/gramio@0.4.12+7be50f8974dcb86c/node_modules/gramio/dist/utils-CJfJNxc_.js
 var exports_utils_CJfJNxc_ = {};
 __export(exports_utils_CJfJNxc_, {
   w: () => withRetries,
@@ -54515,7 +54758,7 @@ class InlineQueryResult {
 }
 Symbol.metadata ??= Symbol("Symbol.metadata");
 
-// ../../node_modules/.bun/gramio@0.4.12+cb432ad7c9c526f6/node_modules/gramio/dist/index.js
+// ../../node_modules/.bun/gramio@0.4.12+7be50f8974dcb86c/node_modules/gramio/dist/index.js
 class Composer2 {
   composer = Composer.builder();
   length = 0;
@@ -102370,6 +102613,1037 @@ function json3(data, status = 200) {
   });
 }
 
+// ../../apps/gateway/src/db/file-roots.ts
+function getFileRoots() {
+  const orm = getDb();
+  return orm.select().from(fileRoots).orderBy(asc(fileRoots.sortOrder), asc(fileRoots.path)).all();
+}
+function getFileRootById(id) {
+  const orm = getDb();
+  return orm.select().from(fileRoots).where(eq(fileRoots.id, id)).get() ?? null;
+}
+function createFileRoot(input) {
+  const orm = getDb();
+  const maxRow = orm.select({ value: max(fileRoots.sortOrder) }).from(fileRoots).get();
+  const record2 = {
+    id: v4_default(),
+    deviceId: input.deviceId,
+    path: input.path,
+    enabled: input.enabled ?? true,
+    sortOrder: (maxRow?.value ?? -1) + 1,
+    createdAt: new Date().toISOString()
+  };
+  orm.insert(fileRoots).values(record2).run();
+  return record2;
+}
+function updateFileRoot(id, updates) {
+  const current = getFileRootById(id);
+  if (!current)
+    return null;
+  const next = {
+    ...current,
+    path: updates.path ?? current.path,
+    enabled: updates.enabled ?? current.enabled,
+    sortOrder: updates.sortOrder ?? current.sortOrder
+  };
+  const orm = getDb();
+  orm.update(fileRoots).set({ path: next.path, enabled: next.enabled, sortOrder: next.sortOrder }).where(eq(fileRoots.id, id)).run();
+  return next;
+}
+function deleteFileRoot(id) {
+  const orm = getDb();
+  const existing = orm.select({ id: fileRoots.id }).from(fileRoots).where(eq(fileRoots.id, id)).get();
+  if (!existing)
+    return false;
+  orm.delete(fileRoots).where(eq(fileRoots.id, id)).run();
+  return true;
+}
+
+// ../../apps/gateway/src/files/device-storage.ts
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync3, realpathSync, rmSync as rmSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join5 } from "path";
+
+// ../../apps/gateway/src/files/categorize.ts
+import { extname } from "path";
+var MAX_ENTRIES = 2000;
+var MAX_TEXT_BYTES = 2 * 1024 * 1024;
+var MARKDOWN_EXTS = new Set(["md", "markdown", "mdx"]);
+var IMAGE_EXTS = new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"]);
+var PDF_EXTS = new Set(["pdf"]);
+var ARCHIVE_EXTS = new Set(["zip", "tar", "gz", "tgz", "bz2", "xz", "7z", "rar", "zst"]);
+var AUDIO_EXTS = new Set(["mp3", "wav", "ogg", "flac", "m4a", "aac"]);
+var VIDEO_EXTS = new Set(["mp4", "webm", "mkv", "mov", "avi", "m4v"]);
+var TEXT_EXTS = new Set(["txt", "text", "log", "csv", "tsv", "rtf"]);
+var CODE_EXTS = new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "json",
+  "jsonc",
+  "json5",
+  "css",
+  "scss",
+  "sass",
+  "less",
+  "html",
+  "htm",
+  "xml",
+  "vue",
+  "svelte",
+  "astro",
+  "py",
+  "pyi",
+  "rb",
+  "go",
+  "rs",
+  "java",
+  "kt",
+  "kts",
+  "c",
+  "h",
+  "cpp",
+  "cc",
+  "cxx",
+  "hpp",
+  "hh",
+  "cs",
+  "php",
+  "swift",
+  "m",
+  "mm",
+  "sh",
+  "bash",
+  "zsh",
+  "fish",
+  "ps1",
+  "bat",
+  "cmd",
+  "sql",
+  "toml",
+  "yaml",
+  "yml",
+  "ini",
+  "cfg",
+  "conf",
+  "env",
+  "properties",
+  "gradle",
+  "lua",
+  "r",
+  "dart",
+  "scala",
+  "clj",
+  "cljs",
+  "ex",
+  "exs",
+  "erl",
+  "hs",
+  "ml",
+  "mli",
+  "pl",
+  "pm",
+  "vim",
+  "lock",
+  "tf",
+  "tfvars",
+  "proto",
+  "graphql",
+  "gql",
+  "prisma",
+  "dockerfile",
+  "makefile",
+  "cmake",
+  "nix",
+  "zig",
+  "d",
+  "jl",
+  "groovy",
+  "patch",
+  "diff"
+]);
+var KNOWN_NOEXT = new Set([
+  "makefile",
+  "dockerfile",
+  "license",
+  "readme",
+  "changelog",
+  "authors",
+  "copying",
+  "notice",
+  "procfile",
+  "gemfile",
+  "rakefile",
+  "brewfile",
+  "caddyfile",
+  ".gitignore",
+  ".gitattributes",
+  ".gitmodules",
+  ".env",
+  ".editorconfig",
+  ".npmrc",
+  ".nvmrc",
+  ".prettierrc",
+  ".eslintrc",
+  ".babelrc",
+  ".dockerignore",
+  ".zshrc",
+  ".bashrc",
+  ".profile"
+]);
+var MIME_MAP = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  svg: "image/svg+xml",
+  avif: "image/avif",
+  pdf: "application/pdf",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mkv: "video/x-matroska",
+  mov: "video/quicktime",
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+  json: "application/json; charset=utf-8",
+  txt: "text/plain; charset=utf-8"
+};
+function extOf(name24) {
+  return extname(name24).slice(1).toLowerCase();
+}
+function categorize(name24) {
+  const lower = name24.toLowerCase();
+  const ext = extOf(lower);
+  if (MARKDOWN_EXTS.has(ext))
+    return "markdown";
+  if (IMAGE_EXTS.has(ext))
+    return "image";
+  if (PDF_EXTS.has(ext))
+    return "pdf";
+  if (ARCHIVE_EXTS.has(ext))
+    return "archive";
+  if (AUDIO_EXTS.has(ext))
+    return "audio";
+  if (VIDEO_EXTS.has(ext))
+    return "video";
+  if (CODE_EXTS.has(ext))
+    return "code";
+  if (TEXT_EXTS.has(ext))
+    return "text";
+  if (!ext && KNOWN_NOEXT.has(lower))
+    return "code";
+  return "other";
+}
+function mimeOf(name24) {
+  return MIME_MAP[extOf(name24)] ?? null;
+}
+
+// ../../apps/gateway/src/files/queue.ts
+var GLOBAL_MAX_CONCURRENT = 4;
+var active = 0;
+var globalWaiters = [];
+var deviceChains = new Map;
+function acquireGlobalSlot() {
+  if (active < GLOBAL_MAX_CONCURRENT) {
+    active += 1;
+    return Promise.resolve();
+  }
+  return new Promise((resolve3) => {
+    globalWaiters.push(() => {
+      active += 1;
+      resolve3();
+    });
+  });
+}
+function releaseGlobalSlot() {
+  active -= 1;
+  const next = globalWaiters.shift();
+  if (next)
+    next();
+}
+function enqueueDeviceJob(deviceId, job) {
+  const prev = deviceChains.get(deviceId) ?? Promise.resolve();
+  const run = prev.catch(() => {
+    return;
+  }).then(async () => {
+    await acquireGlobalSlot();
+    try {
+      return await job();
+    } finally {
+      releaseGlobalSlot();
+    }
+  });
+  deviceChains.set(deviceId, run.then(() => {
+    return;
+  }, () => {
+    return;
+  }));
+  return run;
+}
+
+// ../../apps/gateway/src/files/rsync.ts
+class RsyncMissingLocalError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RsyncMissingLocalError";
+  }
+}
+var SENSITIVE_ENV_KEYS = new Set(["DATABASE_URL", "NODE_ENV", "GATEWAY_PORT", "FE_PORT"]);
+function baseSubprocessEnv() {
+  const out = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === undefined)
+      continue;
+    if (k.startsWith("TMEX_"))
+      continue;
+    if (SENSITIVE_ENV_KEYS.has(k))
+      continue;
+    out[k] = v;
+  }
+  out.LC_ALL = "C";
+  return out;
+}
+async function runRsync(argv, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 20000;
+  let proc;
+  try {
+    proc = Bun.spawn(["rsync", ...argv], {
+      env: { ...baseSubprocessEnv(), ...opts.env },
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore"
+    });
+  } catch (error51) {
+    throw new RsyncMissingLocalError(error51 instanceof Error ? error51.message : String(error51));
+  }
+  let timedOut = false;
+  const killTimer = setTimeout(() => {
+    timedOut = true;
+    try {
+      proc.kill();
+    } catch {}
+  }, timeoutMs);
+  const onAbort = () => {
+    try {
+      proc.kill();
+    } catch {}
+  };
+  opts.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (timedOut) {
+      return { stdout, stderr: `${stderr}
+[tmex] rsync timed out`, exitCode: 124 };
+    }
+    return { stdout, stderr, exitCode };
+  } finally {
+    clearTimeout(killTimer);
+    opts.signal?.removeEventListener("abort", onAbort);
+  }
+}
+var LIST_RE = /^([dlspbc-][rwxsStT-]{9}[.+@]?)\s+([\d,]+)\s+(\d{4})\/(\d{2})\/(\d{2})\s+(\d{2}):(\d{2}):(\d{2})\s+(.*)$/;
+function typeFromPerms(perms) {
+  switch (perms[0]) {
+    case "d":
+      return "dir";
+    case "l":
+      return "symlink";
+    case "-":
+      return "file";
+    default:
+      return "other";
+  }
+}
+function parseListOnly(stdout) {
+  const entries = [];
+  for (const rawLine of stdout.split(`
+`)) {
+    const line = rawLine.replace(/\r$/, "");
+    const m = LIST_RE.exec(line);
+    if (!m)
+      continue;
+    const type = typeFromPerms(m[1]);
+    let name24 = m[9];
+    if (type === "symlink") {
+      const arrow = name24.indexOf(" -> ");
+      if (arrow >= 0)
+        name24 = name24.slice(0, arrow);
+    }
+    if (name24 === "" || name24 === "." || name24 === "..")
+      continue;
+    const sizeNum = Number.parseInt(m[2].replace(/,/g, ""), 10);
+    const size = type === "dir" ? null : Number.isNaN(sizeNum) ? null : sizeNum;
+    const modifiedAt = `${m[3]}-${m[4]}-${m[5]}T${m[6]}:${m[7]}:${m[8]}`;
+    entries.push({ name: name24, type, size, modifiedAt });
+  }
+  return entries;
+}
+function classifyRsyncFailure(exitCode, stderr) {
+  const s = stderr.toLowerCase();
+  if (exitCode === 124)
+    return "timeout";
+  if (/command not found|rsync: not found|rsync error: error in rsync protocol.*\(code 127\)/.test(s)) {
+    return "rsync_missing_remote";
+  }
+  if (/rsync: not found|exec: rsync: not found|bash: rsync/.test(s))
+    return "rsync_missing_remote";
+  if (/host key verification failed|could not resolve hostname|connection refused|connection timed out|no route to host|operation timed out|ssh: connect to host/.test(s)) {
+    return "connection_failed";
+  }
+  if (/permission denied \((publickey|password|keyboard-interactive|gssapi|hostbased)/.test(s) || /too many authentication failures|authentication failed/.test(s)) {
+    return "connection_failed";
+  }
+  if (/permission denied/.test(s))
+    return "permission_denied";
+  if (/no such file or directory|change_dir.*failed|link_stat.*failed|failed to stat/.test(s)) {
+    return "not_found";
+  }
+  return "unknown";
+}
+
+// ../../apps/gateway/src/files/ssh-command.ts
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+class RsyncAuthError extends Error {
+  code;
+  constructor(code2, message) {
+    super(message);
+    this.name = "RsyncAuthError";
+    this.code = code2;
+  }
+}
+var SSH_BASE_OPTS = ["-o", "StrictHostKeyChecking=accept-new", "-o", "ConnectTimeout=10"];
+function setupAskpass(secret) {
+  const dir2 = mkdtempSync(join4(tmpdir(), "tmex-rsync-ap-"));
+  const scriptPath = join4(dir2, "askpass.sh");
+  writeFileSync(scriptPath, `#!/bin/sh
+printf '%s\\n' "$TMEX_RSYNC_SECRET"
+`, { mode: 448 });
+  chmodSync(scriptPath, 448);
+  return {
+    env: {
+      SSH_ASKPASS: scriptPath,
+      SSH_ASKPASS_REQUIRE: "force",
+      TMEX_RSYNC_SECRET: secret,
+      DISPLAY: process.env.DISPLAY || ":0"
+    },
+    cleanup: () => {
+      try {
+        rmSync(dir2, { recursive: true, force: true });
+      } catch {}
+    }
+  };
+}
+function writeTempKey(privateKey) {
+  const dir2 = mkdtempSync(join4(tmpdir(), "tmex-rsync-key-"));
+  const keyPath = join4(dir2, "id");
+  writeFileSync(keyPath, privateKey, { mode: 384 });
+  chmodSync(keyPath, 384);
+  return {
+    keyPath,
+    cleanup: () => {
+      try {
+        rmSync(dir2, { recursive: true, force: true });
+      } catch {}
+    }
+  };
+}
+async function buildRsyncDeviceSpec(device, decrypt2 = decryptWithContext, resolveConfig = resolveSshConnectConfig) {
+  if (device.type === "local") {
+    return { targetPrefix: "", rsh: undefined, env: {}, cleanup: () => {} };
+  }
+  if (device.authMode === "configRef" && device.sshConfigRef?.trim()) {
+    const alias = device.sshConfigRef.trim();
+    return {
+      targetPrefix: `${alias}:`,
+      rsh: ["ssh", ...SSH_BASE_OPTS, "-o", "BatchMode=yes"].join(" "),
+      env: {},
+      cleanup: () => {}
+    };
+  }
+  const cfg = await resolveConfig(device, decrypt2);
+  if (!cfg.host) {
+    throw new RsyncAuthError("connection_failed", "SSH \u8BBE\u5907\u7F3A\u5C11 host");
+  }
+  const port = cfg.port ?? 22;
+  const target = cfg.username ? `${cfg.username}@${cfg.host}` : cfg.host;
+  const sshArgs = ["ssh", "-p", String(port), ...SSH_BASE_OPTS];
+  const env = {};
+  const cleanups = [];
+  if (cfg.privateKey) {
+    const { keyPath, cleanup } = writeTempKey(String(cfg.privateKey));
+    sshArgs.push("-i", keyPath, "-o", "IdentitiesOnly=yes");
+    cleanups.push(cleanup);
+    if (cfg.agent) {
+      env.SSH_AUTH_SOCK = String(cfg.agent);
+      sshArgs.push("-o", "BatchMode=yes");
+    } else if (cfg.passphrase) {
+      const ap = setupAskpass(String(cfg.passphrase));
+      Object.assign(env, ap.env);
+      cleanups.push(ap.cleanup);
+    } else {
+      sshArgs.push("-o", "BatchMode=yes");
+    }
+  } else if (cfg.agent) {
+    env.SSH_AUTH_SOCK = String(cfg.agent);
+    sshArgs.push("-o", "BatchMode=yes");
+  } else if (cfg.password) {
+    const ap = setupAskpass(String(cfg.password));
+    Object.assign(env, ap.env);
+    cleanups.push(ap.cleanup);
+    sshArgs.push("-o", "PreferredAuthentications=password,keyboard-interactive", "-o", "NumberOfPasswordPrompts=1");
+  } else {
+    throw new RsyncAuthError("auth_unsupported", "\u672A\u627E\u5230\u53EF\u7528\u4E8E rsync \u7684\u8BA4\u8BC1\u65B9\u5F0F\uFF08\u5BC6\u94A5 / ssh-agent / \u5BC6\u7801\uFF09");
+  }
+  return {
+    targetPrefix: `${target}:`,
+    rsh: sshArgs.join(" "),
+    env,
+    cleanup: () => {
+      for (const c of cleanups)
+        c();
+    }
+  };
+}
+function rsyncTargetArg(spec, remotePath) {
+  if (!spec.targetPrefix)
+    return remotePath;
+  return `${spec.targetPrefix}${quoteShellArg(remotePath)}`;
+}
+function rsyncListArgs(spec, remotePath) {
+  const args = ["--list-only"];
+  if (spec.rsh)
+    args.push("-e", spec.rsh);
+  args.push(rsyncTargetArg(spec, remotePath));
+  return args;
+}
+function rsyncCopyArgs(spec, remotePath, dest) {
+  const args = ["-L"];
+  if (spec.rsh)
+    args.push("-e", spec.rsh);
+  args.push(rsyncTargetArg(spec, remotePath), dest);
+  return args;
+}
+
+// ../../apps/gateway/src/files/device-storage.ts
+var RAW_MAX_BYTES = 50 * 1024 * 1024;
+var LIST_TIMEOUT_MS = 20000;
+var COPY_TIMEOUT_MS = 60000;
+function ok(data) {
+  return { ok: true, data };
+}
+function fail(code2, detail) {
+  return { ok: false, code: code2, detail };
+}
+function posixNormalize(p) {
+  const isAbs = p.startsWith("/");
+  const out = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".")
+      continue;
+    if (seg === "..") {
+      if (out.length && out[out.length - 1] !== "..")
+        out.pop();
+      else if (!isAbs)
+        out.push("..");
+      continue;
+    }
+    out.push(seg);
+  }
+  const joined = out.join("/");
+  return isAbs ? `/${joined}` : joined;
+}
+function posixJoin(dir2, name24) {
+  return dir2 === "/" ? `/${name24}` : `${dir2}/${name24}`;
+}
+function posixBasename(p) {
+  const i = p.lastIndexOf("/");
+  const base = i >= 0 ? p.slice(i + 1) : p;
+  return base || p;
+}
+function checkAndNormalize(device, rootPath, inputPath) {
+  if (!inputPath || !inputPath.startsWith("/"))
+    return { ok: false, code: "invalid" };
+  const normRoot = posixNormalize(rootPath);
+  const normPath = posixNormalize(inputPath);
+  const prefix = normRoot === "/" ? "/" : `${normRoot}/`;
+  if (!(normPath === normRoot || normPath.startsWith(prefix))) {
+    return { ok: false, code: "outside_roots" };
+  }
+  if (device.type === "local") {
+    let realRoot;
+    let realTarget;
+    try {
+      realRoot = realpathSync(normRoot);
+    } catch {
+      return { ok: false, code: "root_not_found" };
+    }
+    try {
+      realTarget = realpathSync(normPath);
+    } catch {
+      return { ok: false, code: "not_found" };
+    }
+    const rPrefix = realRoot === "/" ? "/" : `${realRoot}/`;
+    if (!(realTarget === realRoot || realTarget.startsWith(rPrefix))) {
+      return { ok: false, code: "outside_roots" };
+    }
+  }
+  return { ok: true, path: normPath };
+}
+function resolveContext(rootId) {
+  const root = getFileRootById(rootId);
+  if (!root)
+    return { ok: false, code: "root_not_found" };
+  if (!root.enabled)
+    return { ok: false, code: "root_disabled" };
+  const device = getDeviceById(root.deviceId);
+  if (!device)
+    return { ok: false, code: "device_not_found" };
+  return { ok: true, ctx: { root, device } };
+}
+function entryToDto(entry, parentPath) {
+  return {
+    name: entry.name,
+    path: posixJoin(parentPath, entry.name),
+    type: entry.type,
+    category: entry.type === "dir" ? "directory" : categorize(entry.name),
+    size: entry.size,
+    modifiedAt: entry.modifiedAt,
+    isSymlink: entry.type === "symlink"
+  };
+}
+function sortEntries(entries) {
+  entries.sort((a, b3) => {
+    const ad = a.type === "dir" ? 0 : 1;
+    const bd = b3.type === "dir" ? 0 : 1;
+    if (ad !== bd)
+      return ad - bd;
+    return a.name.localeCompare(b3.name, undefined, { numeric: true, sensitivity: "base" });
+  });
+}
+function looksBinary(buf) {
+  const len = Math.min(buf.length, 8192);
+  for (let i = 0;i < len; i++) {
+    if (buf[i] === 0)
+      return true;
+  }
+  return false;
+}
+async function listDirectory(rootId, inputPath) {
+  const r = resolveContext(rootId);
+  if (!r.ok)
+    return fail(r.code);
+  const { root, device } = r.ctx;
+  const norm = checkAndNormalize(device, root.path, inputPath ?? root.path);
+  if (!norm.ok)
+    return fail(norm.code);
+  return enqueueDeviceJob(device.id, async () => {
+    let spec;
+    try {
+      spec = await buildRsyncDeviceSpec(device);
+    } catch (error51) {
+      if (error51 instanceof RsyncAuthError)
+        return fail(error51.code, error51.message);
+      throw error51;
+    }
+    try {
+      const listPath = norm.path.endsWith("/") ? norm.path : `${norm.path}/`;
+      let res;
+      try {
+        res = await runRsync(rsyncListArgs(spec, listPath), {
+          env: spec.env,
+          timeoutMs: LIST_TIMEOUT_MS
+        });
+      } catch (error51) {
+        if (error51 instanceof RsyncMissingLocalError)
+          return fail("rsync_missing_local");
+        throw error51;
+      }
+      if (res.exitCode !== 0)
+        return fail(classifyRsyncFailure(res.exitCode, res.stderr), res.stderr);
+      const parsed = parseListOnly(res.stdout);
+      const truncated = parsed.length > MAX_ENTRIES;
+      const slice = truncated ? parsed.slice(0, MAX_ENTRIES) : parsed;
+      const entries = slice.map((e) => entryToDto(e, norm.path));
+      sortEntries(entries);
+      return ok({ path: norm.path, entries, truncated });
+    } finally {
+      spec.cleanup();
+    }
+  });
+}
+async function statViaRsync(spec, normPath) {
+  let res;
+  try {
+    res = await runRsync(rsyncListArgs(spec, normPath), {
+      env: spec.env,
+      timeoutMs: LIST_TIMEOUT_MS
+    });
+  } catch (error51) {
+    if (error51 instanceof RsyncMissingLocalError)
+      return fail("rsync_missing_local");
+    throw error51;
+  }
+  if (res.exitCode !== 0)
+    return fail(classifyRsyncFailure(res.exitCode, res.stderr), res.stderr);
+  const entry = parseListOnly(res.stdout)[0];
+  if (!entry)
+    return fail("not_found");
+  return ok(entry);
+}
+async function statFile(rootId, inputPath) {
+  const r = resolveContext(rootId);
+  if (!r.ok)
+    return fail(r.code);
+  const { root, device } = r.ctx;
+  const norm = checkAndNormalize(device, root.path, inputPath);
+  if (!norm.ok)
+    return fail(norm.code);
+  return enqueueDeviceJob(device.id, async () => {
+    let spec;
+    try {
+      spec = await buildRsyncDeviceSpec(device);
+    } catch (error51) {
+      if (error51 instanceof RsyncAuthError)
+        return fail(error51.code, error51.message);
+      throw error51;
+    }
+    try {
+      const st = await statViaRsync(spec, norm.path);
+      if (!st.ok)
+        return st;
+      const name24 = posixBasename(norm.path);
+      const isDir = st.data.type === "dir";
+      const type = isDir ? "dir" : st.data.type === "symlink" ? "symlink" : "file";
+      return ok({
+        path: norm.path,
+        name: name24,
+        type,
+        category: isDir ? "directory" : categorize(name24),
+        size: isDir ? 0 : st.data.size ?? 0,
+        modifiedAt: st.data.modifiedAt,
+        mime: isDir ? null : mimeOf(name24),
+        isSymlink: st.data.type === "symlink"
+      });
+    } finally {
+      spec.cleanup();
+    }
+  });
+}
+async function copyToBuffer(spec, normPath) {
+  const dir2 = mkdtempSync2(join5(tmpdir2(), "tmex-rfile-"));
+  const dest = join5(dir2, "f");
+  try {
+    let res;
+    try {
+      res = await runRsync(rsyncCopyArgs(spec, normPath, dest), {
+        env: spec.env,
+        timeoutMs: COPY_TIMEOUT_MS
+      });
+    } catch (error51) {
+      if (error51 instanceof RsyncMissingLocalError)
+        return fail("rsync_missing_local");
+      throw error51;
+    }
+    if (res.exitCode !== 0)
+      return fail(classifyRsyncFailure(res.exitCode, res.stderr), res.stderr);
+    return ok(readFileSync3(dest));
+  } finally {
+    try {
+      rmSync2(dir2, { recursive: true, force: true });
+    } catch {}
+  }
+}
+async function readTextFile(rootId, inputPath) {
+  const r = resolveContext(rootId);
+  if (!r.ok)
+    return fail(r.code);
+  const { root, device } = r.ctx;
+  const norm = checkAndNormalize(device, root.path, inputPath);
+  if (!norm.ok)
+    return fail(norm.code);
+  return enqueueDeviceJob(device.id, async () => {
+    let spec;
+    try {
+      spec = await buildRsyncDeviceSpec(device);
+    } catch (error51) {
+      if (error51 instanceof RsyncAuthError)
+        return fail(error51.code, error51.message);
+      throw error51;
+    }
+    try {
+      const st = await statViaRsync(spec, norm.path);
+      if (!st.ok)
+        return st;
+      if (st.data.type === "dir")
+        return fail("is_directory");
+      if (st.data.size != null && st.data.size > MAX_TEXT_BYTES)
+        return fail("too_large");
+      const buf = await copyToBuffer(spec, norm.path);
+      if (!buf.ok)
+        return buf;
+      if (buf.data.length > MAX_TEXT_BYTES)
+        return fail("too_large");
+      if (looksBinary(buf.data))
+        return fail("binary");
+      const name24 = posixBasename(norm.path);
+      return ok({
+        path: norm.path,
+        name: name24,
+        category: categorize(name24),
+        encoding: "utf-8",
+        content: buf.data.toString("utf-8"),
+        size: st.data.size ?? buf.data.length,
+        truncated: false
+      });
+    } finally {
+      spec.cleanup();
+    }
+  });
+}
+async function readRawFile(rootId, inputPath) {
+  const r = resolveContext(rootId);
+  if (!r.ok)
+    return fail(r.code);
+  const { root, device } = r.ctx;
+  const norm = checkAndNormalize(device, root.path, inputPath);
+  if (!norm.ok)
+    return fail(norm.code);
+  return enqueueDeviceJob(device.id, async () => {
+    let spec;
+    try {
+      spec = await buildRsyncDeviceSpec(device);
+    } catch (error51) {
+      if (error51 instanceof RsyncAuthError)
+        return fail(error51.code, error51.message);
+      throw error51;
+    }
+    try {
+      const st = await statViaRsync(spec, norm.path);
+      if (!st.ok)
+        return st;
+      if (st.data.type === "dir")
+        return fail("is_directory");
+      if (st.data.size != null && st.data.size > RAW_MAX_BYTES)
+        return fail("too_large");
+      const buf = await copyToBuffer(spec, norm.path);
+      if (!buf.ok)
+        return buf;
+      if (buf.data.length > RAW_MAX_BYTES)
+        return fail("too_large");
+      const name24 = posixBasename(norm.path);
+      return ok({ data: new Uint8Array(buf.data), name: name24, mime: mimeOf(name24) });
+    } finally {
+      spec.cleanup();
+    }
+  });
+}
+
+// ../../apps/gateway/src/api/files.ts
+function json4(data, status = 200, headers = {}) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...headers }
+  });
+}
+var CODE_STATUS = {
+  invalid: 400,
+  outside_roots: 403,
+  not_found: 404,
+  not_a_directory: 400,
+  is_directory: 400,
+  too_large: 413,
+  binary: 415,
+  permission_denied: 403,
+  device_not_found: 404,
+  root_not_found: 404,
+  root_disabled: 403,
+  connection_failed: 502,
+  auth_unsupported: 400,
+  rsync_missing_local: 502,
+  rsync_missing_remote: 502,
+  timeout: 504,
+  unknown: 500
+};
+function codeError(code2, detail) {
+  return json4({ error: code2, code: code2, detail }, CODE_STATUS[code2]);
+}
+function rootDisplayName(p) {
+  if (p === "/")
+    return "/";
+  const i = p.replace(/\/$/, "").lastIndexOf("/");
+  const base = i >= 0 ? p.replace(/\/$/, "").slice(i + 1) : p;
+  return base || p;
+}
+function toRootDto(root) {
+  const device = getDeviceById(root.deviceId);
+  return {
+    id: root.id,
+    deviceId: root.deviceId,
+    deviceName: device?.name ?? null,
+    deviceType: device?.type ?? null,
+    path: root.path,
+    name: rootDisplayName(root.path),
+    enabled: root.enabled,
+    sortOrder: root.sortOrder
+  };
+}
+function handleListRoots() {
+  return json4({ roots: getFileRoots().map(toRootDto) });
+}
+async function handleCreateRoot(req) {
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return json4({ error: t2("apiError.invalidRequest") }, 400);
+  }
+  const deviceId = typeof body.deviceId === "string" ? body.deviceId : "";
+  const path = typeof body.path === "string" ? body.path.trim() : "";
+  if (!deviceId || !getDeviceById(deviceId)) {
+    return json4({ error: t2("apiError.fileRootDeviceInvalid") }, 400);
+  }
+  if (!path || !path.startsWith("/")) {
+    return json4({ error: t2("apiError.fileRootInvalid") }, 400);
+  }
+  const existing = getFileRoots().find((r) => r.deviceId === deviceId && r.path === path);
+  if (existing) {
+    return json4({ error: t2("apiError.fileRootDuplicate") }, 400);
+  }
+  const record2 = createFileRoot({ deviceId, path, enabled: body.enabled ?? true });
+  return json4({ root: toRootDto(record2) }, 201);
+}
+async function handleUpdateRoot(req, id) {
+  const existing = getFileRootById(id);
+  if (!existing)
+    return json4({ error: t2("apiError.notFound") }, 404);
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return json4({ error: t2("apiError.invalidRequest") }, 400);
+  }
+  const updates = {};
+  if (body.path !== undefined) {
+    const path = typeof body.path === "string" ? body.path.trim() : "";
+    if (!path || !path.startsWith("/"))
+      return json4({ error: t2("apiError.fileRootInvalid") }, 400);
+    const dup = getFileRoots().find((r) => r.id !== id && r.deviceId === existing.deviceId && r.path === path);
+    if (dup)
+      return json4({ error: t2("apiError.fileRootDuplicate") }, 400);
+    updates.path = path;
+  }
+  if (body.enabled !== undefined) {
+    if (typeof body.enabled !== "boolean")
+      return json4({ error: t2("apiError.invalidRequest") }, 400);
+    updates.enabled = body.enabled;
+  }
+  if (body.sortOrder !== undefined) {
+    if (typeof body.sortOrder !== "number")
+      return json4({ error: t2("apiError.invalidRequest") }, 400);
+    updates.sortOrder = body.sortOrder;
+  }
+  const updated = updateFileRoot(id, updates);
+  if (!updated)
+    return json4({ error: t2("apiError.notFound") }, 404);
+  return json4({ root: toRootDto(updated) });
+}
+function handleDeleteRoot(id) {
+  const okDelete = deleteFileRoot(id);
+  if (!okDelete)
+    return json4({ error: t2("apiError.notFound") }, 404);
+  return json4({ success: true });
+}
+async function handleList(url2) {
+  const rootId = url2.searchParams.get("rootId");
+  if (!rootId)
+    return json4({ error: t2("apiError.invalidRequest") }, 400);
+  const path = url2.searchParams.get("path");
+  const result = await listDirectory(rootId, path);
+  if (!result.ok)
+    return codeError(result.code, result.detail);
+  return json4(result.data);
+}
+async function handleContent(url2) {
+  const rootId = url2.searchParams.get("rootId");
+  const path = url2.searchParams.get("path");
+  if (!rootId || !path)
+    return json4({ error: t2("apiError.invalidRequest") }, 400);
+  const result = await readTextFile(rootId, path);
+  if (!result.ok)
+    return codeError(result.code, result.detail);
+  return json4(result.data);
+}
+async function handleStat(url2) {
+  const rootId = url2.searchParams.get("rootId");
+  const path = url2.searchParams.get("path");
+  if (!rootId || !path)
+    return json4({ error: t2("apiError.invalidRequest") }, 400);
+  const result = await statFile(rootId, path);
+  if (!result.ok)
+    return codeError(result.code, result.detail);
+  return json4(result.data);
+}
+async function handleRaw(url2) {
+  const rootId = url2.searchParams.get("rootId");
+  const path = url2.searchParams.get("path");
+  if (!rootId || !path)
+    return json4({ error: t2("apiError.invalidRequest") }, 400);
+  const result = await readRawFile(rootId, path);
+  if (!result.ok)
+    return codeError(result.code, result.detail);
+  const headers = {
+    "Content-Type": result.data.mime ?? "application/octet-stream"
+  };
+  const download2 = url2.searchParams.get("download");
+  if (download2 === "1" || download2 === "true") {
+    const encoded = encodeURIComponent(result.data.name);
+    const ascii = result.data.name.replace(/["\\\r\n]/g, "_");
+    headers["Content-Disposition"] = `attachment; filename="${ascii}"; filename*=UTF-8''${encoded}`;
+  }
+  return new Response(result.data.data, { status: 200, headers });
+}
+function handleFilesApiRequest(req, path) {
+  const url2 = new URL(req.url);
+  if (path === "/api/files/roots" && req.method === "GET")
+    return handleListRoots();
+  if (path === "/api/files/roots" && req.method === "POST")
+    return handleCreateRoot(req);
+  if (path.match(/^\/api\/files\/roots\/[^/]+$/) && req.method === "PATCH") {
+    return handleUpdateRoot(req, decodeURIComponent(path.split("/")[4]));
+  }
+  if (path.match(/^\/api\/files\/roots\/[^/]+$/) && req.method === "DELETE") {
+    return handleDeleteRoot(decodeURIComponent(path.split("/")[4]));
+  }
+  if (path === "/api/files/list" && req.method === "GET")
+    return handleList(url2);
+  if (path === "/api/files/content" && req.method === "GET")
+    return handleContent(url2);
+  if (path === "/api/files/stat" && req.method === "GET")
+    return handleStat(url2);
+  if (path === "/api/files/raw" && req.method === "GET")
+    return handleRaw(url2);
+  return;
+}
+
 // ../../apps/gateway/src/api/llm.ts
 var PROTOCOLS = ["openai-chat", "openai-responses"];
 var SEARCH_PROVIDERS = ["none", "tavily", "brave"];
@@ -102463,31 +103737,31 @@ async function refreshModelsCache(provider) {
 }
 async function handleListProviders() {
   const providers = getAllLlmProviders().map(toProviderDto);
-  return json4({ providers });
+  return json5({ providers });
 }
 async function handleCreateProvider(req) {
   const raw = await readJsonObjectBody2(req);
   if (!raw) {
-    return json4({ error: t2("apiError.invalidRequest") }, 400);
+    return json5({ error: t2("apiError.invalidRequest") }, 400);
   }
   const body = raw;
   const name24 = typeof body.name === "string" ? body.name.trim() : "";
   if (!name24) {
-    return json4({ error: t2("apiError.llmProviderNameRequired") }, 400);
+    return json5({ error: t2("apiError.llmProviderNameRequired") }, 400);
   }
   if (!PROTOCOLS.includes(body.protocol)) {
-    return json4({ error: t2("apiError.llmProviderProtocolInvalid") }, 400);
+    return json5({ error: t2("apiError.llmProviderProtocolInvalid") }, 400);
   }
   const baseUrl = typeof body.baseUrl === "string" ? body.baseUrl.trim() : "";
   if (!baseUrl || !isValidBaseUrl(baseUrl)) {
-    return json4({ error: t2("apiError.llmProviderBaseUrlInvalid") }, 400);
+    return json5({ error: t2("apiError.llmProviderBaseUrlInvalid") }, 400);
   }
   const apiKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
   if (!apiKey) {
-    return json4({ error: t2("apiError.llmProviderApiKeyRequired") }, 400);
+    return json5({ error: t2("apiError.llmProviderApiKeyRequired") }, 400);
   }
   if (body.enabled !== undefined && typeof body.enabled !== "boolean") {
-    return json4({ error: t2("apiError.invalidRequest") }, 400);
+    return json5({ error: t2("apiError.invalidRequest") }, 400);
   }
   const created = createLlmProvider({
     name: name24,
@@ -102497,41 +103771,41 @@ async function handleCreateProvider(req) {
     enabled: body.enabled ?? true
   });
   const { provider, modelsError } = await refreshModelsCache(created);
-  return json4({ provider: toProviderDto(provider), ...modelsError ? { modelsError } : {} }, 201);
+  return json5({ provider: toProviderDto(provider), ...modelsError ? { modelsError } : {} }, 201);
 }
 async function handleUpdateProvider(req, id) {
   const existing = getLlmProviderById(id);
   if (!existing) {
-    return json4({ error: t2("apiError.llmProviderNotFound") }, 404);
+    return json5({ error: t2("apiError.llmProviderNotFound") }, 404);
   }
   const raw = await readJsonObjectBody2(req);
   if (!raw) {
-    return json4({ error: t2("apiError.invalidRequest") }, 400);
+    return json5({ error: t2("apiError.invalidRequest") }, 400);
   }
   const body = raw;
   const updates = {};
   if (body.name !== undefined) {
     const name24 = typeof body.name === "string" ? body.name.trim() : "";
     if (!name24) {
-      return json4({ error: t2("apiError.llmProviderNameRequired") }, 400);
+      return json5({ error: t2("apiError.llmProviderNameRequired") }, 400);
     }
     updates.name = name24;
   }
   if (body.protocol !== undefined) {
     if (!PROTOCOLS.includes(body.protocol)) {
-      return json4({ error: t2("apiError.llmProviderProtocolInvalid") }, 400);
+      return json5({ error: t2("apiError.llmProviderProtocolInvalid") }, 400);
     }
     updates.protocol = body.protocol;
   }
   if (body.baseUrl !== undefined) {
     const baseUrl = typeof body.baseUrl === "string" ? body.baseUrl.trim() : "";
     if (!isValidBaseUrl(baseUrl)) {
-      return json4({ error: t2("apiError.llmProviderBaseUrlInvalid") }, 400);
+      return json5({ error: t2("apiError.llmProviderBaseUrlInvalid") }, 400);
     }
     updates.baseUrl = baseUrl;
   }
   if (body.apiKey !== undefined && typeof body.apiKey !== "string") {
-    return json4({ error: t2("apiError.invalidRequest") }, 400);
+    return json5({ error: t2("apiError.invalidRequest") }, 400);
   }
   const apiKey = body.apiKey?.trim();
   if (apiKey) {
@@ -102539,26 +103813,26 @@ async function handleUpdateProvider(req, id) {
   }
   if (body.enabled !== undefined) {
     if (typeof body.enabled !== "boolean") {
-      return json4({ error: t2("apiError.invalidRequest") }, 400);
+      return json5({ error: t2("apiError.invalidRequest") }, 400);
     }
     updates.enabled = body.enabled;
   }
   const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
   if (body.manualModels !== undefined) {
     if (!isStringArray(body.manualModels)) {
-      return json4({ error: t2("apiError.invalidRequest") }, 400);
+      return json5({ error: t2("apiError.invalidRequest") }, 400);
     }
     updates.manualModels = [...new Set(body.manualModels.map((m) => m.trim()).filter(Boolean))];
   }
   if (body.disabledModels !== undefined) {
     if (!isStringArray(body.disabledModels)) {
-      return json4({ error: t2("apiError.invalidRequest") }, 400);
+      return json5({ error: t2("apiError.invalidRequest") }, 400);
     }
     updates.disabledModels = [...new Set(body.disabledModels.map((m) => m.trim()).filter(Boolean))];
   }
   let provider = updateLlmProvider(id, updates);
   if (!provider) {
-    return json4({ error: t2("apiError.llmProviderNotFound") }, 404);
+    return json5({ error: t2("apiError.llmProviderNotFound") }, 404);
   }
   const credentialsChanged = updates.baseUrl !== undefined && updates.baseUrl !== existing.baseUrl || updates.apiKeyEnc !== undefined;
   let modelsError;
@@ -102567,76 +103841,76 @@ async function handleUpdateProvider(req, id) {
     provider = refreshed.provider;
     modelsError = refreshed.modelsError;
   }
-  return json4({ provider: toProviderDto(provider), ...modelsError ? { modelsError } : {} });
+  return json5({ provider: toProviderDto(provider), ...modelsError ? { modelsError } : {} });
 }
 async function handleDeleteProvider(id) {
   const existing = getLlmProviderById(id);
   if (!existing) {
-    return json4({ error: t2("apiError.llmProviderNotFound") }, 404);
+    return json5({ error: t2("apiError.llmProviderNotFound") }, 404);
   }
   deleteLlmProvider(id);
-  return json4({ success: true });
+  return json5({ success: true });
 }
 async function handleRefreshProviderModels(id) {
   const existing = getLlmProviderById(id);
   if (!existing) {
-    return json4({ error: t2("apiError.llmProviderNotFound") }, 404);
+    return json5({ error: t2("apiError.llmProviderNotFound") }, 404);
   }
   const { models, modelsError } = await refreshModelsCache(existing);
   if (modelsError !== undefined || models === undefined) {
-    return json4({ error: modelsError ?? t2("apiError.invalidRequest") }, 502);
+    return json5({ error: modelsError ?? t2("apiError.invalidRequest") }, 502);
   }
-  return json4({ models });
+  return json5({ models });
 }
 async function handleGetSettings() {
-  return json4({ settings: toSettingsDto(getAgentSettings()) });
+  return json5({ settings: toSettingsDto(getAgentSettings()) });
 }
 async function handleUpdateSettings(req) {
   const raw = await readJsonObjectBody2(req);
   if (!raw) {
-    return json4({ error: t2("apiError.invalidRequest") }, 400);
+    return json5({ error: t2("apiError.invalidRequest") }, 400);
   }
   const body = raw;
   const updates = {};
   if (body.searchProvider !== undefined) {
     if (!SEARCH_PROVIDERS.includes(body.searchProvider)) {
-      return json4({ error: t2("apiError.llmSearchProviderInvalid") }, 400);
+      return json5({ error: t2("apiError.llmSearchProviderInvalid") }, 400);
     }
     updates.searchProvider = body.searchProvider;
   }
   if (body.defaultProviderId !== undefined) {
     if (body.defaultProviderId !== null && typeof body.defaultProviderId !== "string") {
-      return json4({ error: t2("apiError.invalidRequest") }, 400);
+      return json5({ error: t2("apiError.invalidRequest") }, 400);
     }
     if (body.defaultProviderId !== null && !getLlmProviderById(body.defaultProviderId)) {
-      return json4({ error: t2("apiError.llmDefaultProviderNotFound") }, 400);
+      return json5({ error: t2("apiError.llmDefaultProviderNotFound") }, 400);
     }
     updates.defaultProviderId = body.defaultProviderId;
   }
   if (body.defaultModelId !== undefined) {
     if (body.defaultModelId !== null && typeof body.defaultModelId !== "string") {
-      return json4({ error: t2("apiError.invalidRequest") }, 400);
+      return json5({ error: t2("apiError.invalidRequest") }, 400);
     }
     updates.defaultModelId = body.defaultModelId;
   }
   if (body.tavilyApiKey !== undefined) {
     if (typeof body.tavilyApiKey !== "string") {
-      return json4({ error: t2("apiError.invalidRequest") }, 400);
+      return json5({ error: t2("apiError.invalidRequest") }, 400);
     }
     const value = body.tavilyApiKey.trim();
     updates.tavilyApiKeyEnc = value ? await encrypt(value) : null;
   }
   if (body.braveApiKey !== undefined) {
     if (typeof body.braveApiKey !== "string") {
-      return json4({ error: t2("apiError.invalidRequest") }, 400);
+      return json5({ error: t2("apiError.invalidRequest") }, 400);
     }
     const value = body.braveApiKey.trim();
     updates.braveApiKeyEnc = value ? await encrypt(value) : null;
   }
   const settings = updateAgentSettings(updates);
-  return json4({ settings: toSettingsDto(settings) });
+  return json5({ settings: toSettingsDto(settings) });
 }
-function json4(data, status = 200) {
+function json5(data, status = 200) {
   return new Response(JSON.stringify(data), {
     status,
     headers: {
@@ -102652,7 +103926,7 @@ function inferFailurePhase(errorType) {
   }
   return "connect";
 }
-function json5(data, status = 200) {
+function json6(data, status = 200) {
   return new Response(JSON.stringify(data), {
     status,
     headers: {
@@ -102671,7 +103945,7 @@ async function handleDeviceTestConnection(deviceId, inputDeps = {}) {
   };
   const device = deps.getDevice(deviceId);
   if (!device) {
-    return json5({ error: deps.translate("apiError.deviceNotFound") }, 404);
+    return json6({ error: deps.translate("apiError.deviceNotFound") }, 404);
   }
   const classifyErrorResponse = (error51) => {
     const rawMessage = error51 instanceof Error ? error51.message : String(error51);
@@ -102684,7 +103958,7 @@ async function handleDeviceTestConnection(deviceId, inputDeps = {}) {
       message: deps.translate(classified.messageKey, classified.messageParams),
       rawMessage
     };
-    return json5(payload);
+    return json6(payload);
   };
   let runtime = null;
   try {
@@ -102697,7 +103971,7 @@ async function handleDeviceTestConnection(deviceId, inputDeps = {}) {
       phase: "ready",
       message: deps.translate("common.success")
     };
-    return json5(payload);
+    return json6(payload);
   } catch (error51) {
     return classifyErrorResponse(error51);
   } finally {
@@ -103804,35 +105078,35 @@ async function handleListRules(req) {
   if (paneId) {
     rules = rules.filter((rule) => rule.paneId === paneId);
   }
-  return json6({ rules: rules.map(toRuleDto) });
+  return json7({ rules: rules.map(toRuleDto) });
 }
 async function handleCreateRule(req, deps) {
   const raw = await readJsonObjectBody3(req);
   if (!raw) {
-    return json6({ error: t2("apiError.invalidRequest") }, 400);
+    return json7({ error: t2("apiError.invalidRequest") }, 400);
   }
   const body = raw;
   const name24 = typeof body.name === "string" ? body.name.trim() : "";
   if (!name24) {
-    return json6({ error: t2("apiError.watchNameRequired") }, 400);
+    return json7({ error: t2("apiError.watchNameRequired") }, 400);
   }
   const deviceId = typeof body.deviceId === "string" ? body.deviceId.trim() : "";
   if (!deviceId) {
-    return json6({ error: t2("apiError.agentDeviceRequired") }, 400);
+    return json7({ error: t2("apiError.agentDeviceRequired") }, 400);
   }
   if (!getDeviceById(deviceId)) {
-    return json6({ error: t2("apiError.deviceNotFound") }, 404);
+    return json7({ error: t2("apiError.deviceNotFound") }, 404);
   }
   const paneId = typeof body.paneId === "string" ? body.paneId.trim() : "";
   if (!paneId) {
-    return json6({ error: t2("apiError.agentPaneRequired") }, 400);
+    return json7({ error: t2("apiError.agentPaneRequired") }, 400);
   }
   if (!TRIGGER_TYPES.includes(body.triggerType)) {
-    return json6({ error: t2("apiError.watchTriggerTypeInvalid") }, 400);
+    return json7({ error: t2("apiError.watchTriggerTypeInvalid") }, 400);
   }
   const parsed = parseRuleFields(raw);
   if (!parsed.ok) {
-    return json6({ error: parsed.error }, 400);
+    return json7({ error: parsed.error }, 400);
   }
   const fields = parsed.fields;
   const effective = {
@@ -103845,7 +105119,7 @@ async function handleCreateRule(req, deps) {
   };
   const semanticError = validateRuleSemantics(effective);
   if (semanticError) {
-    return json6({ error: semanticError }, 400);
+    return json7({ error: semanticError }, 400);
   }
   const rule = createWatchRule({
     name: name24,
@@ -103868,50 +105142,50 @@ async function handleCreateRule(req, deps) {
     cooldownSeconds: fields.cooldownSeconds
   });
   await deps.service.refreshRule(rule.id);
-  return json6({ rule: toRuleDto(rule), state: null }, 201);
+  return json7({ rule: toRuleDto(rule), state: null }, 201);
 }
 async function handleGetRule(id) {
   const rule = getWatchRuleById(id);
   if (!rule) {
-    return json6({ error: t2("apiError.watchRuleNotFound") }, 404);
+    return json7({ error: t2("apiError.watchRuleNotFound") }, 404);
   }
   const state = getWatchRuleState(id);
-  return json6({ rule: toRuleDto(rule), state: state ? toStateDto(state) : null });
+  return json7({ rule: toRuleDto(rule), state: state ? toStateDto(state) : null });
 }
 async function handleUpdateRule(req, id, deps) {
   const existing = getWatchRuleById(id);
   if (!existing) {
-    return json6({ error: t2("apiError.watchRuleNotFound") }, 404);
+    return json7({ error: t2("apiError.watchRuleNotFound") }, 404);
   }
   const raw = await readJsonObjectBody3(req);
   if (!raw) {
-    return json6({ error: t2("apiError.invalidRequest") }, 400);
+    return json7({ error: t2("apiError.invalidRequest") }, 400);
   }
   const body = raw;
   const updates = {};
   if (body.name !== undefined) {
     const name24 = typeof body.name === "string" ? body.name.trim() : "";
     if (!name24) {
-      return json6({ error: t2("apiError.watchNameRequired") }, 400);
+      return json7({ error: t2("apiError.watchNameRequired") }, 400);
     }
     updates.name = name24;
   }
   if (body.paneId !== undefined) {
     const paneId = typeof body.paneId === "string" ? body.paneId.trim() : "";
     if (!paneId) {
-      return json6({ error: t2("apiError.agentPaneRequired") }, 400);
+      return json7({ error: t2("apiError.agentPaneRequired") }, 400);
     }
     updates.paneId = paneId;
   }
   if (body.triggerType !== undefined) {
     if (!TRIGGER_TYPES.includes(body.triggerType)) {
-      return json6({ error: t2("apiError.watchTriggerTypeInvalid") }, 400);
+      return json7({ error: t2("apiError.watchTriggerTypeInvalid") }, 400);
     }
     updates.triggerType = body.triggerType;
   }
   const parsed = parseRuleFields(raw);
   if (!parsed.ok) {
-    return json6({ error: parsed.error }, 400);
+    return json7({ error: parsed.error }, 400);
   }
   const fields = parsed.fields;
   Object.assign(updates, fields);
@@ -103925,32 +105199,32 @@ async function handleUpdateRule(req, id, deps) {
   };
   const semanticError = validateRuleSemantics(effective);
   if (semanticError) {
-    return json6({ error: semanticError }, 400);
+    return json7({ error: semanticError }, 400);
   }
   const rule = updateWatchRule(id, updates);
   if (!rule) {
-    return json6({ error: t2("apiError.watchRuleNotFound") }, 404);
+    return json7({ error: t2("apiError.watchRuleNotFound") }, 404);
   }
   await deps.service.refreshRule(id);
   const state = getWatchRuleState(id);
-  return json6({ rule: toRuleDto(rule), state: state ? toStateDto(state) : null });
+  return json7({ rule: toRuleDto(rule), state: state ? toStateDto(state) : null });
 }
 async function handleDeleteRule(id, deps) {
   const existing = getWatchRuleById(id);
   if (!existing) {
-    return json6({ error: t2("apiError.watchRuleNotFound") }, 404);
+    return json7({ error: t2("apiError.watchRuleNotFound") }, 404);
   }
   deleteWatchRule(id);
   await deps.service.removeRule(id);
-  return json6({ success: true });
+  return json7({ success: true });
 }
 async function handleGetRuleState(id, deps) {
   const rule = getWatchRuleById(id);
   if (!rule) {
-    return json6({ error: t2("apiError.watchRuleNotFound") }, 404);
+    return json7({ error: t2("apiError.watchRuleNotFound") }, 404);
   }
   const state = getWatchRuleState(id);
-  return json6({
+  return json7({
     state: state ? toStateDto(state) : null,
     samples: deps.service.getSamples(id)
   });
@@ -103974,17 +105248,17 @@ function buildAssistPrompt(description, screen) {
 async function handleAssistRegex(req, deps) {
   const raw = await readJsonObjectBody3(req);
   if (!raw) {
-    return json6({ error: t2("apiError.invalidRequest") }, 400);
+    return json7({ error: t2("apiError.invalidRequest") }, 400);
   }
   const body = raw;
   const description = typeof body.description === "string" ? body.description.trim() : "";
   if (!description) {
-    return json6({ error: t2("apiError.watchAssistDescriptionRequired") }, 400);
+    return json7({ error: t2("apiError.watchAssistDescriptionRequired") }, 400);
   }
   let providerId = null;
   if (body.providerId !== undefined && body.providerId !== null) {
     if (typeof body.providerId !== "string" || !getLlmProviderById(body.providerId)) {
-      return json6({ error: t2("apiError.llmProviderNotFound") }, 400);
+      return json7({ error: t2("apiError.llmProviderNotFound") }, 400);
     }
     providerId = body.providerId;
   }
@@ -103994,7 +105268,7 @@ async function handleAssistRegex(req, deps) {
   const paneId = typeof body.paneId === "string" ? body.paneId.trim() : "";
   if (deviceId && paneId) {
     if (!getDeviceById(deviceId)) {
-      return json6({ error: t2("apiError.deviceNotFound") }, 404);
+      return json7({ error: t2("apiError.deviceNotFound") }, 404);
     }
     try {
       screen = await deps.captureScreen(deviceId, paneId);
@@ -104015,14 +105289,14 @@ async function handleAssistRegex(req, deps) {
     object3 = result.object;
   } catch (error51) {
     const detail = error51 instanceof Error ? error51.message : String(error51);
-    return json6({ error: t2("apiError.watchAssistModelUnavailable", { detail }) }, 502);
+    return json7({ error: t2("apiError.watchAssistModelUnavailable", { detail }) }, 502);
   }
   let regex;
   try {
     regex = compileWatchPattern(object3.pattern, object3.flags);
   } catch (error51) {
     const detail = error51 instanceof Error ? error51.message : String(error51);
-    return json6({ error: t2("apiError.watchPatternInvalid", { detail }) }, 502);
+    return json7({ error: t2("apiError.watchPatternInvalid", { detail }) }, 502);
   }
   const preview = [];
   if (screen) {
@@ -104036,7 +105310,7 @@ async function handleAssistRegex(req, deps) {
       match = regex.exec(screen);
     }
   }
-  return json6({
+  return json7({
     pattern: object3.pattern,
     flags: object3.flags,
     extractGroup: object3.extractGroup >= 0 ? object3.extractGroup : 0,
@@ -104044,7 +105318,7 @@ async function handleAssistRegex(req, deps) {
     preview
   });
 }
-function json6(data, status = 200) {
+function json7(data, status = 200) {
   return new Response(JSON.stringify(data), {
     status,
     headers: {
@@ -104228,6 +105502,12 @@ function handleApiRequest(req, _server) {
       return watchResponse;
     }
   }
+  if (path.startsWith("/api/files")) {
+    const filesResponse = handleFilesApiRequest(req, path);
+    if (filesResponse) {
+      return filesResponse;
+    }
+  }
   if (path === "/api/webhooks" && req.method === "GET") {
     return handleGetWebhooks();
   }
@@ -104241,9 +105521,9 @@ function handleApiRequest(req, _server) {
     return handleGetManifest(req.method);
   }
   if (path === "/healthz" && req.method === "GET") {
-    return json7({ status: "ok", restarting: runtimeController.isRestarting() });
+    return json8({ status: "ok", restarting: runtimeController.isRestarting() });
   }
-  return json7({ error: t2("apiError.notFound") }, 404);
+  return json8({ error: t2("apiError.notFound") }, 404);
 }
 function enrichDeviceWithRuntime(device) {
   const status = getDeviceRuntimeStatus(device.id);
@@ -104257,22 +105537,22 @@ function enrichDeviceWithRuntime(device) {
 }
 async function handleGetDevices() {
   const devices2 = getAllDevices().map(enrichDeviceWithRuntime);
-  return json7({ devices: devices2 });
+  return json8({ devices: devices2 });
 }
 async function handleGetDevice(id) {
   const device = getDeviceById(id);
   if (!device) {
-    return json7({ error: t2("apiError.deviceNotFound") }, 404);
+    return json8({ error: t2("apiError.deviceNotFound") }, 404);
   }
-  return json7({ device: enrichDeviceWithRuntime(device) });
+  return json8({ device: enrichDeviceWithRuntime(device) });
 }
 async function handleCreateDevice(req) {
   const body = await req.json();
   if (!body.name || !body.type || !body.authMode) {
-    return json7({ error: t2("apiError.missingFields") }, 400);
+    return json8({ error: t2("apiError.missingFields") }, 400);
   }
   if (body.type === "ssh" && !body.host && !body.sshConfigRef) {
-    return json7({ error: t2("apiError.sshRequiresHost") }, 400);
+    return json8({ error: t2("apiError.sshRequiresHost") }, 400);
   }
   const now2 = new Date().toISOString();
   const device = {
@@ -104294,12 +105574,12 @@ async function handleCreateDevice(req) {
   };
   createDevice(device);
   await pushSupervisor.upsert(device.id);
-  return json7({ device: getDeviceById(device.id) ?? device }, 201);
+  return json8({ device: getDeviceById(device.id) ?? device }, 201);
 }
 async function handleUpdateDevice(req, id) {
   const existing = getDeviceById(id);
   if (!existing) {
-    return json7({ error: t2("apiError.deviceNotFound") }, 404);
+    return json8({ error: t2("apiError.deviceNotFound") }, 404);
   }
   const body = await req.json();
   const updates = {};
@@ -104329,61 +105609,61 @@ async function handleUpdateDevice(req, id) {
     await pushSupervisor.reconnect(id);
   }
   const device = getDeviceById(id);
-  return json7({ device });
+  return json8({ device });
 }
 async function handleReorderDevices(req) {
   const body = await req.json();
   if (!Array.isArray(body.deviceIds) || body.deviceIds.some((id) => typeof id !== "string")) {
-    return json7({ error: t2("apiError.invalidRequest") }, 400);
+    return json8({ error: t2("apiError.invalidRequest") }, 400);
   }
   reorderDevices(body.deviceIds);
-  return json7({ devices: getAllDevices().map(enrichDeviceWithRuntime) });
+  return json8({ devices: getAllDevices().map(enrichDeviceWithRuntime) });
 }
 async function handleDeleteDevice(id) {
   const existing = getDeviceById(id);
   if (!existing) {
-    return json7({ error: t2("apiError.deviceNotFound") }, 404);
+    return json8({ error: t2("apiError.deviceNotFound") }, 404);
   }
   deleteDevice(id);
   pushSupervisor.remove(id);
-  return json7({ success: true });
+  return json8({ success: true });
 }
 async function handleTestConnection(id) {
   return handleDeviceTestConnection(id);
 }
 async function handleGetSiteSettings() {
-  return json7({ settings: getSiteSettings() });
+  return json8({ settings: getSiteSettings() });
 }
 async function handleUpdateSiteSettings(req) {
   try {
     const body = await req.json();
     const updates = normalizeSiteSettingsInput(body);
     const settings = updateSiteSettings(updates);
-    return json7({ settings });
+    return json8({ settings });
   } catch (err) {
-    return json7({ error: err instanceof Error ? err.message : t2("apiError.invalidRequest") }, 400);
+    return json8({ error: err instanceof Error ? err.message : t2("apiError.invalidRequest") }, 400);
   }
 }
 async function handleRestartGateway() {
   setTimeout(() => {
     runtimeController.requestRestart();
   }, 50);
-  return json7({
+  return json8({
     success: true,
     message: t2("settings.restartScheduled")
   });
 }
 async function handleGetTelegramBots() {
   const bots = getTelegramBotsWithStats();
-  return json7({ bots });
+  return json8({ bots });
 }
 async function handleCreateTelegramBot(req) {
   const body = await req.json();
   if (!body.name?.trim()) {
-    return json7({ error: t2("apiError.botNameRequired") }, 400);
+    return json8({ error: t2("apiError.botNameRequired") }, 400);
   }
   if (!body.token?.trim()) {
-    return json7({ error: t2("apiError.botTokenRequired") }, 400);
+    return json8({ error: t2("apiError.botTokenRequired") }, 400);
   }
   const now2 = new Date().toISOString();
   createTelegramBot({
@@ -104397,26 +105677,26 @@ async function handleCreateTelegramBot(req) {
     updatedAt: now2
   });
   await telegramService.refresh();
-  return json7({ success: true }, 201);
+  return json8({ success: true }, 201);
 }
 async function handleUpdateTelegramBot(req, botId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json7({ error: t2("apiError.botNotFound") }, 404);
+    return json8({ error: t2("apiError.botNotFound") }, 404);
   }
   const body = await req.json();
   const updates = {};
   if (body.name !== undefined) {
     const value = body.name.trim();
     if (!value) {
-      return json7({ error: t2("apiError.botNameRequired") }, 400);
+      return json8({ error: t2("apiError.botNameRequired") }, 400);
     }
     updates.name = value;
   }
   if (body.token !== undefined) {
     const token = body.token.trim();
     if (!token) {
-      return json7({ error: t2("apiError.botTokenRequired") }, 400);
+      return json8({ error: t2("apiError.botTokenRequired") }, 400);
     }
     updates.tokenEnc = await encrypt(token);
   }
@@ -104428,69 +105708,69 @@ async function handleUpdateTelegramBot(req, botId) {
   }
   updateTelegramBot(botId, updates);
   await telegramService.refresh();
-  return json7({ success: true });
+  return json8({ success: true });
 }
 async function handleDeleteTelegramBot(botId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json7({ error: t2("apiError.botNotFound") }, 404);
+    return json8({ error: t2("apiError.botNotFound") }, 404);
   }
   deleteTelegramBot(botId);
   await telegramService.refresh();
-  return json7({ success: true });
+  return json8({ success: true });
 }
 async function handleListTelegramChats(botId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json7({ error: t2("apiError.botNotFound") }, 404);
+    return json8({ error: t2("apiError.botNotFound") }, 404);
   }
   const chats = listTelegramChatsByBot(botId);
-  return json7({ chats });
+  return json8({ chats });
 }
 async function handleApproveTelegramChat(botId, chatId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json7({ error: t2("apiError.botNotFound") }, 404);
+    return json8({ error: t2("apiError.botNotFound") }, 404);
   }
   const chat = approveTelegramChat(botId, chatId);
   if (!chat) {
-    return json7({ error: t2("apiError.chatNotFound") }, 404);
+    return json8({ error: t2("apiError.chatNotFound") }, 404);
   }
   const settings = getSiteSettings();
   await telegramService.sendTestMessage(botId, chatId, t2("telegram.approveMessageTemplate", {
     botName: existing.name,
     time: new Date().toLocaleString(toBCP47(settings.language))
   }));
-  return json7({ chat });
+  return json8({ chat });
 }
 async function handleDeleteTelegramChat(botId, chatId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json7({ error: t2("apiError.botNotFound") }, 404);
+    return json8({ error: t2("apiError.botNotFound") }, 404);
   }
   deleteTelegramChat(botId, chatId);
-  return json7({ success: true });
+  return json8({ success: true });
 }
 async function handleTestTelegramChat(botId, chatId) {
   const bot = getTelegramBotById(botId);
   if (!bot) {
-    return json7({ error: t2("apiError.botNotFound") }, 404);
+    return json8({ error: t2("apiError.botNotFound") }, 404);
   }
   const settings = getSiteSettings();
   await telegramService.sendTestMessage(botId, chatId, t2("telegram.testMessageTemplate", {
     siteName: settings.siteName,
     time: new Date().toLocaleString(toBCP47(settings.language))
   }));
-  return json7({ success: true });
+  return json8({ success: true });
 }
 async function handleGetWebhooks() {
   const webhooks = getAllWebhookEndpoints();
-  return json7({ webhooks });
+  return json8({ webhooks });
 }
 async function handleCreateWebhook(req) {
   const body = await req.json();
   if (!body.url || !body.secret) {
-    return json7({ error: t2("apiError.urlAndSecretRequired") }, 400);
+    return json8({ error: t2("apiError.urlAndSecretRequired") }, 400);
   }
   const now2 = new Date().toISOString();
   const endpoint = {
@@ -104503,11 +105783,11 @@ async function handleCreateWebhook(req) {
     updatedAt: now2
   };
   createWebhookEndpoint(endpoint);
-  return json7({ webhook: endpoint }, 201);
+  return json8({ webhook: endpoint }, 201);
 }
 async function handleDeleteWebhook(id) {
   deleteWebhookEndpoint(id);
-  return json7({ success: true });
+  return json8({ success: true });
 }
 async function handleGetManifest(method) {
   const settings = getSiteSettings();
@@ -104546,7 +105826,7 @@ function manifestJson(data, method) {
     }
   });
 }
-function json7(data, status = 200, headers = {}) {
+function json8(data, status = 200, headers = {}) {
   return new Response(JSON.stringify(data), {
     status,
     headers: {
@@ -106387,7 +107667,7 @@ function t3(key, vars) {
 }
 
 // src/runtime/server.ts
-var MIME_MAP = {
+var MIME_MAP2 = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
   ".mjs": "text/javascript; charset=utf-8",
@@ -106403,8 +107683,8 @@ var MIME_MAP = {
   ".map": "application/json; charset=utf-8"
 };
 function contentTypeByPath(path) {
-  const ext = extname(path).toLowerCase();
-  return MIME_MAP[ext];
+  const ext = extname2(path).toLowerCase();
+  return MIME_MAP2[ext];
 }
 function resolveStaticRoot() {
   if (process.env.TMEX_FE_DIST_DIR) {
@@ -106432,10 +107712,10 @@ async function serveFrontend(req, staticRoot) {
   if (!requestedPath) {
     return new Response(t3("runtime.forbidden"), { status: 403 });
   }
-  if (!existsSync5(requestedPath) && extname(url2.pathname) !== "") {
+  if (!existsSync5(requestedPath) && extname2(url2.pathname) !== "") {
     return new Response(t3("runtime.notFound"), { status: 404 });
   }
-  const indexPath = join4(staticRoot, "index.html");
+  const indexPath = join6(staticRoot, "index.html");
   const targetPath = existsSync5(requestedPath) ? requestedPath : indexPath;
   if (!existsSync5(targetPath)) {
     return new Response(t3("runtime.frontendMissing"), { status: 500 });