@todoforai/edge 0.12.7 → 0.12.9

package/dist/index.js

@@ -2900,8 +2900,8 @@ var require_utils = __commonJS((exports) => {
     var lastError;
     for (var _i = 0, dirs_1 = dirs;_i < dirs_1.length; _i++) {
       var d = dirs_1[_i];
-      for (var _a = 0, relative_1 = relative;_a < relative_1.length; _a++) {
-        var r = relative_1[_a];
+      for (var _a2 = 0, relative_1 = relative;_a2 < relative_1.length; _a2++) {
+        var r = relative_1[_a2];
         var dir = r + "/" + d + "/";
         try {
           return { dir, module: __require(dir + "/" + name + ".node") };
@@ -2931,9 +2931,9 @@ var require_eventEmitter2 = __commonJS((exports) => {
             _this._listeners.push(listener);
             var disposable = {
               dispose: function() {
-                for (var i = 0;i < _this._listeners.length; i++) {
-                  if (_this._listeners[i] === listener) {
-                    _this._listeners.splice(i, 1);
+                for (var i2 = 0;i2 < _this._listeners.length; i2++) {
+                  if (_this._listeners[i2] === listener) {
+                    _this._listeners.splice(i2, 1);
                     return;
                   }
                 }
@@ -2949,11 +2949,11 @@ var require_eventEmitter2 = __commonJS((exports) => {
     });
     EventEmitter22.prototype.fire = function(data) {
       var queue = [];
-      for (var i = 0;i < this._listeners.length; i++) {
-        queue.push(this._listeners[i]);
+      for (var i2 = 0;i2 < this._listeners.length; i2++) {
+        queue.push(this._listeners[i2]);
       }
-      for (var i = 0;i < queue.length; i++) {
-        queue[i].call(undefined, data);
+      for (var i2 = 0;i2 < queue.length; i2++) {
+        queue[i2].call(undefined, data);
       }
     };
     return EventEmitter22;
@@ -3063,9 +3063,9 @@ var require_terminal = __commonJS((exports) => {
       }
       if (allowArray) {
         if (Array.isArray(value)) {
-          value.forEach(function(v, i) {
+          value.forEach(function(v, i2) {
             if (typeof v !== type) {
-              throw new Error(name + "[" + i + "] must be a " + type + " (not a " + typeof v[i] + ")");
+              throw new Error(name + "[" + i2 + "] must be a " + type + " (not a " + typeof v[i2] + ")");
             }
           });
           return;
@@ -3137,11 +3137,11 @@ var require_terminal = __commonJS((exports) => {
     Terminal2.prototype._parseEnv = function(env) {
       var keys = Object.keys(env || {});
       var pairs = [];
-      for (var i = 0;i < keys.length; i++) {
-        if (keys[i] === undefined) {
+      for (var i2 = 0;i2 < keys.length; i2++) {
+        if (keys[i2] === undefined) {
           continue;
         }
-        pairs.push(keys[i] + "=" + env[keys[i]]);
+        pairs.push(keys[i2] + "=" + env[keys[i2]]);
       }
       return pairs;
     };
@@ -3323,12 +3323,12 @@ var require_windowsConoutConnection = __commonJS((exports) => {
     };
     ConoutConnection2.prototype._destroySocket = function() {
       return __awaiter(this, undefined, undefined, function() {
-        return __generator(this, function(_a) {
-          switch (_a.label) {
+        return __generator(this, function(_a2) {
+          switch (_a2.label) {
             case 0:
               return [4, this._worker.terminate()];
             case 1:
-              _a.sent();
+              _a2.sent();
               return [2];
           }
         });
@@ -3344,7 +3344,7 @@ var require_windowsPtyAgent = __commonJS((exports) => {
   var __dirname = "/home/runner/work/edge/edge/bun/node_modules/node-pty/lib";
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.argsToCommandLine = exports.WindowsPtyAgent = undefined;
-  var fs4 = __require("fs");
+  var fs5 = __require("fs");
   var os3 = __require("os");
   var path5 = __require("path");
   var child_process_1 = __require("child_process");
@@ -3401,7 +3401,7 @@ var require_windowsPtyAgent = __commonJS((exports) => {
       this._outSocket.on("connect", function() {
         _this._outSocket.emit("ready_datapipe");
       });
-      var inSocketFD = fs4.openSync(term.conin, "w");
+      var inSocketFD = fs5.openSync(term.conin, "w");
       this._inSocket = new net_1.Socket({
         fd: inSocketFD,
         readable: false,
@@ -3588,8 +3588,8 @@ var require_windowsPtyAgent = __commonJS((exports) => {
         result += '"';
       }
       var bsCount = 0;
-      for (var i = 0;i < arg.length; i++) {
-        var p = arg[i];
+      for (var i2 = 0;i2 < arg.length; i2++) {
+        var p = arg[i2];
         if (p === "\\") {
           bsCount++;
         } else if (p === '"') {
@@ -3617,7 +3617,7 @@ var require_windowsPtyAgent = __commonJS((exports) => {
   }
   function repeatText(text, count) {
     var result = "";
-    for (var i = 0;i < count; i++) {
+    for (var i2 = 0;i2 < count; i2++) {
       result += text;
     }
     return result;
@@ -3631,12 +3631,12 @@ var require_windowsPtyAgent = __commonJS((exports) => {
 var require_windowsTerminal = __commonJS((exports) => {
   var __extends = exports && exports.__extends || function() {
     var extendStatics = function(d, b) {
-      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-        d2.__proto__ = b2;
-      } || function(d2, b2) {
-        for (var p in b2)
-          if (b2.hasOwnProperty(p))
-            d2[p] = b2[p];
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b3) {
+        d2.__proto__ = b3;
+      } || function(d2, b3) {
+        for (var p in b3)
+          if (b3.hasOwnProperty(p))
+            d2[p] = b3[p];
       };
       return extendStatics(d, b);
     };
@@ -3690,14 +3690,14 @@ var require_windowsTerminal = __commonJS((exports) => {
             _this._deferreds = [];
           }
         });
-        _this._socket.on("error", function(err) {
+        _this._socket.on("error", function(err2) {
           _this._close();
-          if (err.code) {
-            if (~err.code.indexOf("errno 5") || ~err.code.indexOf("EIO"))
+          if (err2.code) {
+            if (~err2.code.indexOf("errno 5") || ~err2.code.indexOf("EIO"))
               return;
           }
           if (_this.listeners("error").length < 2) {
-            throw err;
+            throw err2;
           }
         });
         _this._socket.on("close", function() {
@@ -3809,12 +3809,12 @@ var require_unixTerminal = __commonJS((exports) => {
   var __dirname = "/home/runner/work/edge/edge/bun/node_modules/node-pty/lib";
   var __extends = exports && exports.__extends || function() {
     var extendStatics = function(d, b) {
-      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-        d2.__proto__ = b2;
-      } || function(d2, b2) {
-        for (var p in b2)
-          if (b2.hasOwnProperty(p))
-            d2[p] = b2[p];
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b3) {
+        d2.__proto__ = b3;
+      } || function(d2, b3) {
+        for (var p in b3)
+          if (b3.hasOwnProperty(p))
+            d2[p] = b3[p];
       };
       return extendStatics(d, b);
     };
@@ -3828,7 +3828,7 @@ var require_unixTerminal = __commonJS((exports) => {
   }();
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.UnixTerminal = undefined;
-  var fs4 = __require("fs");
+  var fs5 = __require("fs");
   var path5 = __require("path");
   var tty = __require("tty");
   var terminal_1 = require_terminal();
@@ -3845,7 +3845,7 @@ var require_unixTerminal = __commonJS((exports) => {
   var UnixTerminal = function(_super) {
     __extends(UnixTerminal2, _super);
     function UnixTerminal2(file, args, opt) {
-      var _a, _b;
+      var _a2, _b2;
       var _this = _super.call(this, opt) || this;
       _this._boundClose = false;
       _this._emittedClose = false;
@@ -3858,8 +3858,8 @@ var require_unixTerminal = __commonJS((exports) => {
       opt.env = opt.env || process.env;
       _this._cols = opt.cols || terminal_1.DEFAULT_COLS;
       _this._rows = opt.rows || terminal_1.DEFAULT_ROWS;
-      var uid = (_a = opt.uid) !== null && _a !== undefined ? _a : -1;
-      var gid = (_b = opt.gid) !== null && _b !== undefined ? _b : -1;
+      var uid = (_a2 = opt.uid) !== null && _a2 !== undefined ? _a2 : -1;
+      var gid = (_b2 = opt.gid) !== null && _b2 !== undefined ? _b2 : -1;
       var env = utils_1.assign({}, opt.env);
       if (opt.env === process.env) {
         _this._sanitizeEnv(env);
@@ -3896,9 +3896,9 @@ var require_unixTerminal = __commonJS((exports) => {
         _this._socket.setEncoding(encoding);
       }
       _this._writeStream = new CustomWriteStream(term.fd, encoding || undefined);
-      _this._socket.on("error", function(err) {
-        if (err.code) {
-          if (~err.code.indexOf("EAGAIN")) {
+      _this._socket.on("error", function(err2) {
+        if (err2.code) {
+          if (~err2.code.indexOf("EAGAIN")) {
             return;
           }
         }
@@ -3907,13 +3907,13 @@ var require_unixTerminal = __commonJS((exports) => {
           _this._emittedClose = true;
           _this.emit("close");
         }
-        if (err.code) {
-          if (~err.code.indexOf("errno 5") || ~err.code.indexOf("EIO")) {
+        if (err2.code) {
+          if (~err2.code.indexOf("errno 5") || ~err2.code.indexOf("EIO")) {
             return;
           }
         }
         if (_this.listeners("error").length < 2) {
-          throw err;
+          throw err2;
         }
       });
       _this._pid = term.pid;
@@ -3996,10 +3996,10 @@ var require_unixTerminal = __commonJS((exports) => {
       self._name = process.env.TERM || "";
       self._readable = true;
       self._writable = true;
-      self._socket.on("error", function(err) {
+      self._socket.on("error", function(err2) {
         self._close();
         if (self.listeners("error").length < 2) {
-          throw err;
+          throw err2;
         }
       });
       self._socket.on("close", function() {
@@ -4080,15 +4080,15 @@ var require_unixTerminal = __commonJS((exports) => {
         return;
       }
       var task = this._writeQueue[0];
-      fs4.write(this._fd, task.buffer, task.offset, function(err, written) {
-        if (err) {
-          if ("code" in err && err.code === "EAGAIN") {
+      fs5.write(this._fd, task.buffer, task.offset, function(err2, written) {
+        if (err2) {
+          if ("code" in err2 && err2.code === "EAGAIN") {
             _this._writeImmediate = setImmediate(function() {
               return _this._processWriteQueue();
             });
           } else {
             _this._writeQueue.length = 0;
-            console.error("Unhandled pty write error", err);
+            console.error("Unhandled pty write error", err2);
           }
           return;
         }
@@ -4133,6 +4133,333 @@ var require_lib = __commonJS((exports) => {
   exports.native = process.platform !== "win32" ? utils_1.loadNativeModule("pty").module : null;
 });
 
+// node_modules/ignore/index.js
+var require_ignore = __commonJS((exports, module) => {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var UNDEFINED = undefined;
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+  var REGEX_TEST_TRAILING_SLASH = /\/$/;
+  var SLASH = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define = (object, key, value) => {
+    Object.defineProperty(object, key, { value });
+    return value;
+  };
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*\\\*\\\*\\\//,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ]
+  ];
+  var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+  var MODE_IGNORE = "regex";
+  var MODE_CHECK_IGNORE = "checkRegex";
+  var UNDERSCORE = "_";
+  var TRAILING_WILD_CARD_REPLACERS = {
+    [MODE_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    },
+    [MODE_CHECK_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }
+  };
+  var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+
+  class IgnoreRule {
+    constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+      this.pattern = pattern;
+      this.mark = mark;
+      this.negative = negative;
+      define(this, "body", body);
+      define(this, "ignoreCase", ignoreCase);
+      define(this, "regexPrefix", prefix);
+    }
+    get regex() {
+      const key = UNDERSCORE + MODE_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_IGNORE, key);
+    }
+    get checkRegex() {
+      const key = UNDERSCORE + MODE_CHECK_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_CHECK_IGNORE, key);
+    }
+    _make(mode, key) {
+      const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
+      const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+      return define(this, key, regex);
+    }
+  }
+  var createRule = ({
+    pattern,
+    mark
+  }, ignoreCase) => {
+    let negative = false;
+    let body = pattern;
+    if (body.indexOf("!") === 0) {
+      negative = true;
+      body = body.substr(1);
+    }
+    body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regexPrefix = makeRegexPrefix(body);
+    return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
+  };
+
+  class RuleManager {
+    constructor(ignoreCase) {
+      this._ignoreCase = ignoreCase;
+      this._rules = [];
+    }
+    _add(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules._rules);
+        this._added = true;
+        return;
+      }
+      if (isString(pattern)) {
+        pattern = {
+          pattern
+        };
+      }
+      if (checkPattern(pattern.pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+      return this._added;
+    }
+    test(path6, checkUnignored, mode) {
+      let ignored = false;
+      let unignored = false;
+      let matchedRule;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule[mode].test(path6);
+        if (!matched) {
+          return;
+        }
+        ignored = !negative;
+        unignored = negative;
+        matchedRule = negative ? UNDEFINED : rule;
+      });
+      const ret = {
+        ignored,
+        unignored
+      };
+      if (matchedRule) {
+        ret.rule = matchedRule;
+      }
+      return ret;
+    }
+  }
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path6, originalPath, doThrow) => {
+    if (!isString(path6)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path6) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path6)) {
+      const r = "`path.relative()`d";
+      return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path6) => REGEX_TEST_INVALID_PATH.test(path6);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p) => p;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define(this, KEY_IGNORE, true);
+      this._rules = new RuleManager(ignoreCase);
+      this._strictPathCheck = !allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    add(pattern) {
+      if (this._rules.add(pattern)) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _test(originalPath, cache, checkUnignored, slices) {
+      const path6 = originalPath && checkPath.convert(originalPath);
+      checkPath(path6, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path6, cache, checkUnignored, slices);
+    }
+    checkIgnore(path6) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path6)) {
+        return this.test(path6);
+      }
+      const slices = path6.split(SLASH).filter(Boolean);
+      slices.pop();
+      if (slices.length) {
+        const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
+        if (parent.ignored) {
+          return parent;
+        }
+      }
+      return this._rules.test(path6, false, MODE_CHECK_IGNORE);
+    }
+    _t(path6, cache, checkUnignored, slices) {
+      if (path6 in cache) {
+        return cache[path6];
+      }
+      if (!slices) {
+        slices = path6.split(SLASH).filter(Boolean);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache[path6] = this._rules.test(path6, checkUnignored, MODE_IGNORE);
+      }
+      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+      return cache[path6] = parent.ignored ? parent : this._rules.test(path6, checkUnignored, MODE_IGNORE);
+    }
+    ignores(path6) {
+      return this._test(path6, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path6) => !this.ignores(path6);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path6) {
+      return this._test(path6, this._testCache, true);
+    }
+  }
+  var factory = (options) => new Ignore(options);
+  var isPathValid = (path6) => checkPath(path6 && checkPath.convert(path6), path6, RETURN_FALSE);
+  var setupWindows = () => {
+    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path6) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path6) || isNotRelative(path6);
+  };
+  if (typeof process !== "undefined" && process.platform === "win32") {
+    setupWindows();
+  }
+  module.exports = factory;
+  factory.default = factory;
+  module.exports.isPathValid = isPathValid;
+  define(module.exports, Symbol.for("setupWindows"), setupWindows);
+});
+
 // src/config.ts
 import { parseArgs } from "util";
 import path from "path";
@@ -4202,6 +4529,9 @@ var FE = {
   TASK_ACTION_NEW: "task_action:new",
   EDGE_CD: "edge:cd",
   GET_FOLDERS: "edge:get_folders",
+  EDGE_CREATE_FOLDER: "edge:create_folder",
+  EDGE_DELETE_PATH: "edge:delete_path",
+  EDGE_WRITE_FILE: "edge:write_file",
   BLOCK_EXECUTE: "block:execute",
   BLOCK_SAVE: "block:save",
   BLOCK_KEYBOARD: "block:keyboard",
@@ -4225,6 +4555,9 @@ var EF = {
   EDGE_STATUS: "edge:status",
   EDGE_CD_RESPONSE: "edge:cd_response",
   EDGE_GET_FOLDERS_RESPONSE: "edge:get_folders_response",
+  EDGE_CREATE_FOLDER_RESPONSE: "edge:create_folder_response",
+  EDGE_DELETE_PATH_RESPONSE: "edge:delete_path_response",
+  EDGE_WRITE_FILE_RESPONSE: "edge:write_file_response",
   BLOCK_SAVE_RESULT: "block:save_result",
   BLOCK_ERROR_RESULT: "block:error_result",
   BLOCK_META_RESULT: "block:meta_result",
@@ -4304,6 +4637,24 @@ var msg = {
       payload.error = error;
     return { type: EA.FUNCTION_CALL_RESULT_AGENT, payload };
   },
+  createFolderResponse(requestId, edgeId, success, error) {
+    const payload = { requestId, edgeId, success };
+    if (error)
+      payload.error = error;
+    return { type: EF.EDGE_CREATE_FOLDER_RESPONSE, payload };
+  },
+  deletePathResponse(requestId, edgeId, success, error) {
+    const payload = { requestId, edgeId, success };
+    if (error)
+      payload.error = error;
+    return { type: EF.EDGE_DELETE_PATH_RESPONSE, payload };
+  },
+  writeFileResponse(requestId, edgeId, success, error) {
+    const payload = { requestId, edgeId, success };
+    if (error)
+      payload.error = error;
+    return { type: EF.EDGE_WRITE_FILE_RESPONSE, payload };
+  },
   functionCallResultFront(requestId, edgeId, success, result, error, blockInfo) {
     const payload = { requestId, edgeId, success };
     if (result != null)
@@ -4385,8 +4736,14 @@ class ApiClient {
   updateTodoStatus(todoId, status) {
     return this.request("PUT", `/api/v1/todos/${todoId}`, { status });
   }
-  listAgentSettings() {
-    return this.request("GET", "/api/v1/agents");
+  listAgentSettings(filters) {
+    const params = new URLSearchParams;
+    if (filters?.workspacePath)
+      params.set("workspacePath", filters.workspacePath);
+    if (filters?.name)
+      params.set("name", filters.name);
+    const qs = params.toString();
+    return this.request("GET", `/api/v1/agents${qs ? `?${qs}` : ""}`);
   }
   getAgentSettings(id) {
     return this.request("GET", `/api/v1/agents/${id}`);
@@ -4428,6 +4785,8 @@ class FrontendWebSocket {
   callbacks = new Map;
   completionEvents = new Map;
   completionResults = new Map;
+  pendingBlocks = new Map;
+  lastReadyPayload = new Map;
   constructor(apiUrl, apiKey) {
     this.apiUrl = apiUrl;
     this.apiKey = apiKey;
@@ -4476,6 +4835,8 @@ class FrontendWebSocket {
     this.callbacks.clear();
     this.completionEvents.clear();
     this.completionResults.clear();
+    this.pendingBlocks.clear();
+    this.lastReadyPayload.clear();
   }
   handleMessage(data) {
     const msgType = data.type || "";
@@ -4488,9 +4849,38 @@ class FrontendWebSocket {
         this.callbacks.get(todoId)(msgType, payload);
       } catch {}
     }
-    if (msgType === "todo:msg_done" && todoId) {
-      this.completionResults.set(todoId, { type: msgType, payload, success: true });
-      this.completionEvents.get(todoId)?.resolve(this.completionResults.get(todoId));
+    if (msgType === "BLOCK_UPDATE" && todoId && payload.blockId && payload.updates?.status === "AWAITING_APPROVAL") {
+      if (!this.pendingBlocks.has(todoId))
+        this.pendingBlocks.set(todoId, new Set);
+      this.pendingBlocks.get(todoId).add(payload.blockId);
+    }
+    if (msgType === "BLOCK_UPDATE" && todoId && payload.blockId) {
+      const status = payload.updates?.status;
+      if (["COMPLETED", "DENIED", "FAILED", "ERROR"].includes(status)) {
+        this.pendingBlocks.get(todoId)?.delete(payload.blockId);
+        const pending = this.pendingBlocks.get(todoId);
+        if (!pending || pending.size === 0) {
+          this.lastReadyPayload.delete(todoId);
+        }
+      }
+    }
+    if (msgType === "todo:status" && todoId) {
+      const status = payload.status;
+      if (status === "RUNNING") {
+        this.lastReadyPayload.delete(todoId);
+      } else if (status === "READY" || status === "READY_CHECKED") {
+        const pending = this.pendingBlocks.get(todoId);
+        if (!pending || pending.size === 0) {
+          this.completionResults.set(todoId, { type: msgType, payload, success: true });
+          this.completionEvents.get(todoId)?.resolve(this.completionResults.get(todoId));
+        } else {
+          this.lastReadyPayload.set(todoId, payload);
+        }
+      } else if (["DONE", "CANCELLED", "CANCELLED_CHECKED", "ERROR", "ERROR_CHECKED"].includes(status)) {
+        const success = status === "DONE";
+        this.completionResults.set(todoId, { type: msgType, payload, success });
+        this.completionEvents.get(todoId)?.resolve(this.completionResults.get(todoId));
+      }
     }
   }
   async subscribe(todoId, callback) {
@@ -4574,7 +4964,8 @@ class FrontendWebSocket {
 }
 
 // src/handlers.ts
-import fs6 from "fs";
+import fs7 from "fs";
+import { mkdir, rm, writeFile } from "fs/promises";
 import path7 from "path";
 
 // src/path-utils.ts
@@ -4672,30 +5063,1077 @@ function getPathOrDefault(p) {
 }
 
 // src/files.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import path3 from "path";
+
+// src/docx-handler.ts
+import fs2 from "fs";
+
+// node_modules/fflate/esm/index.mjs
+import { createRequire as createRequire2 } from "module";
+var require2 = createRequire2("/");
+var Worker;
+try {
+  Worker = require2("worker_threads").Worker;
+} catch (e) {}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
+var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0;i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1;i < 30; ++i) {
+    for (var j = b[i];j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0;i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = function(cd, mb, r) {
+  var s = cd.length;
+  var i2 = 0;
+  var l = new u16(mb);
+  for (;i2 < s; ++i2) {
+    if (cd[i2])
+      ++l[cd[i2] - 1];
+  }
+  var le = new u16(mb);
+  for (i2 = 1;i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v = le[cd[i2] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1;v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+      }
+    }
+  }
+  return co;
+};
+var flt = new u8(288);
+for (i = 0;i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144;i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256;i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280;i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0;i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i2 = 1;i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+];
+var err = function(ind, msg2, nt) {
+  var e = new Error(msg2 || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i2 = 0;i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0;i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i2++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (;; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (;bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (;bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var wbits = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+};
+var wbits16 = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+  d[o + 2] |= v >> 16;
+};
+var hTree = function(d, mb) {
+  var t = [];
+  for (var i2 = 0;i2 < d.length; ++i2) {
+    if (d[i2])
+      t.push({ s: i2, f: d[i2] });
+  }
+  var s = t.length;
+  var t2 = t.slice();
+  if (!s)
+    return { t: et, l: 0 };
+  if (s == 1) {
+    var v = new u8(t[0].s + 1);
+    v[t[0].s] = 1;
+    return { t: v, l: 1 };
+  }
+  t.sort(function(a, b) {
+    return a.f - b.f;
+  });
+  t.push({ s: -1, f: 25001 });
+  var l = t[0], r = t[1], i0 = 0, i1 = 1, i22 = 2;
+  t[0] = { s: -1, f: l.f + r.f, l, r };
+  while (i1 != s - 1) {
+    l = t[t[i0].f < t[i22].f ? i0++ : i22++];
+    r = t[i0 != i1 && t[i0].f < t[i22].f ? i0++ : i22++];
+    t[i1++] = { s: -1, f: l.f + r.f, l, r };
+  }
+  var maxSym = t2[0].s;
+  for (var i2 = 1;i2 < s; ++i2) {
+    if (t2[i2].s > maxSym)
+      maxSym = t2[i2].s;
+  }
+  var tr = new u16(maxSym + 1);
+  var mbt = ln(t[i1 - 1], tr, 0);
+  if (mbt > mb) {
+    var i2 = 0, dt = 0;
+    var lft = mbt - mb, cst = 1 << lft;
+    t2.sort(function(a, b) {
+      return tr[b.s] - tr[a.s] || a.f - b.f;
+    });
+    for (;i2 < s; ++i2) {
+      var i2_1 = t2[i2].s;
+      if (tr[i2_1] > mb) {
+        dt += cst - (1 << mbt - tr[i2_1]);
+        tr[i2_1] = mb;
+      } else
+        break;
+    }
+    dt >>= lft;
+    while (dt > 0) {
+      var i2_2 = t2[i2].s;
+      if (tr[i2_2] < mb)
+        dt -= 1 << mb - tr[i2_2]++ - 1;
+      else
+        ++i2;
+    }
+    for (;i2 >= 0 && dt; --i2) {
+      var i2_3 = t2[i2].s;
+      if (tr[i2_3] == mb) {
+        --tr[i2_3];
+        ++dt;
+      }
+    }
+    mbt = mb;
+  }
+  return { t: new u8(tr), l: mbt };
+};
+var ln = function(n, l, d) {
+  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+};
+var lc = function(c) {
+  var s = c.length;
+  while (s && !c[--s])
+    ;
+  var cl = new u16(++s);
+  var cli = 0, cln = c[0], cls = 1;
+  var w = function(v) {
+    cl[cli++] = v;
+  };
+  for (var i2 = 1;i2 <= s; ++i2) {
+    if (c[i2] == cln && i2 != s)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (;cls > 138; cls -= 138)
+          w(32754);
+        if (cls > 2) {
+          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w(cln), --cls;
+        for (;cls > 6; cls -= 6)
+          w(8304);
+        if (cls > 2)
+          w(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w(cln);
+      cls = 1;
+      cln = c[i2];
+    }
+  }
+  return { c: cl.subarray(0, cli), n: s };
+};
+var clen = function(cf, cl) {
+  var l = 0;
+  for (var i2 = 0;i2 < cl.length; ++i2)
+    l += cf[i2] * cl[i2];
+  return l;
+};
+var wfblk = function(out, pos, dat) {
+  var s = dat.length;
+  var o = shft(pos + 2);
+  out[o] = s & 255;
+  out[o + 1] = s >> 8;
+  out[o + 2] = out[o] ^ 255;
+  out[o + 3] = out[o + 1] ^ 255;
+  for (var i2 = 0;i2 < s; ++i2)
+    out[o + i2 + 4] = dat[i2];
+  return (o + 4 + s) * 8;
+};
+var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+  wbits(out, p++, final);
+  ++lf[256];
+  var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+  var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+  var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+  var lcfreq = new u16(19);
+  for (var i2 = 0;i2 < lclt.length; ++i2)
+    ++lcfreq[lclt[i2] & 31];
+  for (var i2 = 0;i2 < lcdt.length; ++i2)
+    ++lcfreq[lcdt[i2] & 31];
+  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+  var nlcc = 19;
+  for (;nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl + 5 << 3;
+  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p, dat.subarray(bs, bs + bl));
+  var lm, ll, dm, dl;
+  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+  if (dtlen < ftlen) {
+    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p, nlc - 257);
+    wbits(out, p + 5, ndc - 1);
+    wbits(out, p + 10, nlcc - 4);
+    p += 14;
+    for (var i2 = 0;i2 < nlcc; ++i2)
+      wbits(out, p + 3 * i2, lct[clim[i2]]);
+    p += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it = 0;it < 2; ++it) {
+      var clct = lcts[it];
+      for (var i2 = 0;i2 < clct.length; ++i2) {
+        var len = clct[i2] & 31;
+        wbits(out, p, llm[len]), p += lct[len];
+        if (len > 15)
+          wbits(out, p, clct[i2] >> 5 & 127), p += clct[i2] >> 12;
+      }
+    }
+  } else {
+    lm = flm, ll = flt, dm = fdm, dl = fdt;
+  }
+  for (var i2 = 0;i2 < li; ++i2) {
+    var sym = syms[i2];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+      if (len > 7)
+        wbits(out, p, sym >> 23 & 31), p += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p, dm[dst]), p += dl[dst];
+      if (dst > 3)
+        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+    } else {
+      wbits16(out, p, lm[sym]), p += ll[sym];
+    }
+  }
+  wbits16(out, p, lm[256]);
+  return p + ll[256];
+};
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et = /* @__PURE__ */ new u8(0);
+var dflt = function(dat, lvl, plvl, pre, post, st) {
+  var s = st.z || dat.length;
+  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);
+  var w = o.subarray(pre, o.length - post);
+  var lst = st.l;
+  var pos = (st.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w[0] = st.r >> 3;
+    var opt = deo[lvl - 1];
+    var n = opt >> 13, c = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i3) {
+      return (dat[i3] ^ dat[i3 + 1] << bs1_1 ^ dat[i3 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25000);
+    var lf = new u16(288), df = new u16(32);
+    var lc_1 = 0, eb = 0, i2 = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+    for (;i2 + 2 < s; ++i2) {
+      var hv = hsh(i2);
+      var imod = i2 & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi <= i2) {
+        var rem = s - i2;
+        if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i2 - bs, pos);
+          li = lc_1 = eb = 0, bs = i2;
+          for (var j = 0;j < 286; ++j)
+            lf[j] = 0;
+          for (var j = 0;j < 30; ++j)
+            df[j] = 0;
+        }
+        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i2 - dif)) {
+          var maxn = Math.min(n, rem) - 1;
+          var maxd = Math.min(32767, i2);
+          var ml = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i2 + l] == dat[i2 + l - dif]) {
+              var nl = 0;
+              for (;nl < ml && dat[i2 + nl] == dat[i2 + nl - dif]; ++nl)
+                ;
+              if (nl > l) {
+                l = nl, d = dif;
+                if (nl > maxn)
+                  break;
+                var mmd = Math.min(dif, nl - 2);
+                var md = 0;
+                for (var j = 0;j < mmd; ++j) {
+                  var ti = i2 - dif + j & 32767;
+                  var pti = prev[ti];
+                  var cd = ti - pti & 32767;
+                  if (cd > md)
+                    md = cd, pimod = ti;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d) {
+          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+          var lin = revfl[l] & 31, din = revfd[d] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf[257 + lin];
+          ++df[din];
+          wi = i2 + l;
+          ++lc_1;
+        } else {
+          syms[li++] = dat[i2];
+          ++lf[dat[i2]];
+        }
+      }
+    }
+    for (i2 = Math.max(i2, wi);i2 < s; ++i2) {
+      syms[li++] = dat[i2];
+      ++lf[dat[i2]];
+    }
+    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i2 - bs, pos);
+    if (!lst) {
+      st.r = pos & 7 | w[pos / 8 | 0] << 3;
+      pos -= 7;
+      st.h = head, st.p = prev, st.i = i2, st.w = wi;
+    }
+  } else {
+    for (var i2 = st.w || 0;i2 < s + lst; i2 += 65535) {
+      var e = i2 + 65535;
+      if (e >= s) {
+        w[pos / 8 | 0] = lst;
+        e = s;
+      }
+      pos = wfblk(w, pos + 1, dat.subarray(i2, e));
+    }
+    st.i = s;
+  }
+  return slc(o, 0, pre + shft(pos) + post);
+};
+var crct = /* @__PURE__ */ function() {
+  var t = new Int32Array(256);
+  for (var i2 = 0;i2 < 256; ++i2) {
+    var c = i2, k = 9;
+    while (--k)
+      c = (c & 1 && -306674912) ^ c >>> 1;
+    t[i2] = c;
+  }
+  return t;
+}();
+var crc = function() {
+  var c = -1;
+  return {
+    p: function(d) {
+      var cr = c;
+      for (var i2 = 0;i2 < d.length; ++i2)
+        cr = crct[cr & 255 ^ d[i2]] ^ cr >>> 8;
+      c = cr;
+    },
+    d: function() {
+      return ~c;
+    }
+  };
+};
+var dopt = function(dat, opt, pre, post, st) {
+  if (!st) {
+    st = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+};
+var mrg = function(a, b) {
+  var o = {};
+  for (var k in a)
+    o[k] = a[k];
+  for (var k in b)
+    o[k] = b[k];
+  return o;
+};
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+var wbytes = function(d, b, v) {
+  for (;v; ++b)
+    d[b] = v, v >>>= 8;
+};
+function deflateSync(data, opts) {
+  return dopt(data, opts || {}, 0, 0);
+}
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var fltn = function(d, p, t, o) {
+  for (var k in d) {
+    var val = d[k], n = p + k, op = o;
+    if (Array.isArray(val))
+      op = mrg(o, val[1]), val = val[0];
+    if (val instanceof u8)
+      t[n] = [val, op];
+    else {
+      t[n += "/"] = [new u8(0), op];
+      fltn(val, n, t, o);
+    }
+  }
+};
+var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder;
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {}
+var dutf8 = function(d) {
+  for (var r = "", i2 = 0;; ) {
+    var c = d[i2++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i2 + eb > d.length)
+      return { s: r, r: slc(d, i2 - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+  }
+};
+function strToU8(str, latin1) {
+  if (latin1) {
+    var ar_1 = new u8(str.length);
+    for (var i2 = 0;i2 < str.length; ++i2)
+      ar_1[i2] = str.charCodeAt(i2);
+    return ar_1;
+  }
+  if (te)
+    return te.encode(str);
+  var l = str.length;
+  var ar = new u8(str.length + (str.length >> 1));
+  var ai = 0;
+  var w = function(v) {
+    ar[ai++] = v;
+  };
+  for (var i2 = 0;i2 < l; ++i2) {
+    if (ai + 5 > ar.length) {
+      var n = new u8(ai + 8 + (l - i2 << 1));
+      n.set(ar);
+      ar = n;
+    }
+    var c = str.charCodeAt(i2);
+    if (c < 128 || latin1)
+      w(c);
+    else if (c < 2048)
+      w(192 | c >> 6), w(128 | c & 63);
+    else if (c > 55295 && c < 57344)
+      c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i2) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
+    else
+      w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
+  }
+  return slc(ar, 0, ai);
+}
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i2 = 0;i2 < dat.length; i2 += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var slzh = function(d, b) {
+  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+  var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
+  var _a2 = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a2[0], su = _a2[1], off = _a2[2];
+  return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
+};
+var z64e = function(d, b) {
+  for (;b2(d, b) != 1; b += 4 + b2(d, b + 2))
+    ;
+  return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+};
+var exfl = function(ex) {
+  var le = 0;
+  if (ex) {
+    for (var k in ex) {
+      var l = ex[k].length;
+      if (l > 65535)
+        err(9);
+      le += l + 4;
+    }
+  }
+  return le;
+};
+var wzh = function(d, b, f, fn, u, c, ce, co) {
+  var fl2 = fn.length, ex = f.extra, col = co && co.length;
+  var exl = exfl(ex);
+  wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
+  if (ce != null)
+    d[b++] = 20, d[b++] = f.os;
+  d[b] = 20, b += 2;
+  d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
+  d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
+  var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
+  if (y < 0 || y > 119)
+    err(10);
+  wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
+  if (c != -1) {
+    wbytes(d, b, f.crc);
+    wbytes(d, b + 4, c < 0 ? -c - 2 : c);
+    wbytes(d, b + 8, f.size);
+  }
+  wbytes(d, b + 12, fl2);
+  wbytes(d, b + 14, exl), b += 16;
+  if (ce != null) {
+    wbytes(d, b, col);
+    wbytes(d, b + 6, f.attrs);
+    wbytes(d, b + 10, ce), b += 14;
+  }
+  d.set(fn, b);
+  b += fl2;
+  if (exl) {
+    for (var k in ex) {
+      var exf = ex[k], l = exf.length;
+      wbytes(d, b, +k);
+      wbytes(d, b + 2, l);
+      d.set(exf, b + 4), b += 4 + l;
+    }
+  }
+  if (col)
+    d.set(co, b), b += col;
+  return b;
+};
+var wzf = function(o, b, c, d, e) {
+  wbytes(o, b, 101010256);
+  wbytes(o, b + 8, c);
+  wbytes(o, b + 10, c);
+  wbytes(o, b + 12, d);
+  wbytes(o, b + 16, e);
+};
+function zipSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var r = {};
+  var files = [];
+  fltn(data, "", r, opts);
+  var o = 0;
+  var tot = 0;
+  for (var fn in r) {
+    var _a2 = r[fn], file = _a2[0], p = _a2[1];
+    var compression = p.level == 0 ? 0 : 8;
+    var f = strToU8(fn), s = f.length;
+    var com = p.comment, m = com && strToU8(com), ms = m && m.length;
+    var exl = exfl(p.extra);
+    if (s > 65535)
+      err(11);
+    var d = compression ? deflateSync(file, p) : file, l = d.length;
+    var c = crc();
+    c.p(file);
+    files.push(mrg(p, {
+      size: file.length,
+      crc: c.d(),
+      c: d,
+      f,
+      m,
+      u: s != fn.length || m && com.length != ms,
+      o,
+      compression
+    }));
+    o += 30 + s + exl + l;
+    tot += 76 + 2 * (s + exl) + (ms || 0) + l;
+  }
+  var out = new u8(tot + 22), oe = o, cdl = tot - o;
+  for (var i2 = 0;i2 < files.length; ++i2) {
+    var f = files[i2];
+    wzh(out, f.o, f, f.f, f.u, f.c.length);
+    var badd = 30 + f.f.length + exfl(f.extra);
+    out.set(f.c, f.o + badd);
+    wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
+  }
+  wzf(out, o, files.length, cdl, oe);
+  return out;
+}
+function unzipSync(data, opts) {
+  var files = {};
+  var e = data.length - 22;
+  for (;b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558)
+      err(13);
+  }
+  var c = b2(data, e + 8);
+  if (!c)
+    return {};
+  var o = b4(data, e + 16);
+  var z = o == 4294967295 || c == 65535;
+  if (z) {
+    var ze = b4(data, e - 12);
+    z = b4(data, ze) == 101075792;
+    if (z) {
+      c = b4(data, ze + 32);
+      o = b4(data, ze + 48);
+    }
+  }
+  var fltr = opts && opts.filter;
+  for (var i2 = 0;i2 < c; ++i2) {
+    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o = no;
+    if (!fltr || fltr({
+      name: fn,
+      size: sc,
+      originalSize: su,
+      compression: c_2
+    })) {
+      if (!c_2)
+        files[fn] = slc(data, b, b + sc);
+      else if (c_2 == 8)
+        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+      else
+        err(14, "unknown compression type " + c_2);
+    }
+  }
+  return files;
+}
+
+// src/docx-handler.ts
+function prettyPrintXml(xml) {
+  let formatted = "";
+  let indent = 0;
+  const parts = xml.replace(/>\s*</g, "><").split(/(<[^>]+>)/);
+  for (const part of parts) {
+    if (!part.trim())
+      continue;
+    if (part.startsWith("</")) {
+      indent = Math.max(indent - 1, 0);
+      formatted += "  ".repeat(indent) + part + `
+`;
+    } else if (part.startsWith("<?")) {
+      formatted += part + `
+`;
+    } else if (part.startsWith("<") && !part.endsWith("/>") && !part.startsWith("<!")) {
+      formatted += "  ".repeat(indent) + part + `
+`;
+      indent++;
+    } else if (part.endsWith("/>")) {
+      formatted += "  ".repeat(indent) + part + `
+`;
+    } else {
+      formatted += "  ".repeat(indent) + part + `
+`;
+    }
+  }
+  return formatted;
+}
+function parseMultiFileContent(content) {
+  const result = {};
+  const parts = content.split("=== FILE: ");
+  for (const part of parts.slice(1)) {
+    const endIdx = part.indexOf(" ===");
+    if (endIdx === -1)
+      continue;
+    const filename = part.slice(0, endIdx);
+    const xmlContent = part.slice(endIdx + 4).trim();
+    if (filename && xmlContent)
+      result[filename] = xmlContent;
+  }
+  return result;
+}
+function dumpMultiFileContent(filesMap) {
+  const parts = [];
+  for (const [key, content] of Object.entries(filesMap)) {
+    parts.push(`=== FILE: ${key} ===`);
+    parts.push(content.trim());
+  }
+  return parts.join(`
+
+`);
+}
+function cleanHeaderFromXml(xmlContent) {
+  const lines = xmlContent.split(`
+`);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    if (lines[i2].trim().startsWith("<?xml")) {
+      return lines.slice(i2).join(`
+`);
+    }
+  }
+  return xmlContent;
+}
+function extractDocxContent(docxPath) {
+  const data = new Uint8Array(fs2.readFileSync(docxPath));
+  const zip = unzipSync(data);
+  const docXml = zip["word/document.xml"];
+  if (!docXml)
+    throw new Error("Invalid DOCX: 'word/document.xml' not found");
+  const xml = new TextDecoder().decode(docXml);
+  return prettyPrintXml(xml);
+}
+function saveDocxContent(docxPath, xmlContent) {
+  const data = new Uint8Array(fs2.readFileSync(docxPath));
+  const zip = unzipSync(data);
+  if (!zip["word/document.xml"]) {
+    throw new Error("Invalid DOCX: 'word/document.xml' not found");
+  }
+  const cleanXml = cleanHeaderFromXml(xmlContent);
+  zip["word/document.xml"] = new TextEncoder().encode(cleanXml);
+  const out = zipSync(zip);
+  const tmpPath = docxPath + ".tmp";
+  try {
+    fs2.writeFileSync(tmpPath, out);
+    fs2.renameSync(tmpPath, docxPath);
+  } catch (e) {
+    try {
+      fs2.unlinkSync(tmpPath);
+    } catch {}
+    throw e;
+  }
+}
+function extractXlsxContent(xlsxPath) {
+  const data = new Uint8Array(fs2.readFileSync(xlsxPath));
+  const zip = unzipSync(data);
+  const result = {};
+  for (const name of Object.keys(zip)) {
+    if (name.startsWith("xl/worksheets/") && name.endsWith(".xml")) {
+      const key = name.replace("xl/", "");
+      result[key] = prettyPrintXml(new TextDecoder().decode(zip[name]));
+    }
+  }
+  if (zip["xl/sharedStrings.xml"]) {
+    result["sharedStrings.xml"] = prettyPrintXml(new TextDecoder().decode(zip["xl/sharedStrings.xml"]));
+  }
+  if (zip["xl/styles.xml"]) {
+    result["styles.xml"] = prettyPrintXml(new TextDecoder().decode(zip["xl/styles.xml"]));
+  }
+  return dumpMultiFileContent(result);
+}
+function saveXlsxContent(xlsxPath, multiFileContent) {
+  const xmlFiles = parseMultiFileContent(multiFileContent);
+  const data = new Uint8Array(fs2.readFileSync(xlsxPath));
+  const zip = unzipSync(data);
+  for (const [key, xmlContent] of Object.entries(xmlFiles)) {
+    const fullPath = `xl/${key}`;
+    const cleanXml = cleanHeaderFromXml(xmlContent);
+    zip[fullPath] = new TextEncoder().encode(cleanXml);
+  }
+  const out = zipSync(zip);
+  const tmpPath = xlsxPath + ".tmp";
+  try {
+    fs2.writeFileSync(tmpPath, out);
+    fs2.renameSync(tmpPath, xlsxPath);
+  } catch (e) {
+    try {
+      fs2.unlinkSync(tmpPath);
+    } catch {}
+    throw e;
+  }
+}
+
+// src/files.ts
 var MAX_FILE_SIZE = 1e5;
+var MAX_OFFICE_FILE_SIZE = 500000;
+var OFFICE_EXTENSIONS = new Set([".docx", ".xlsx"]);
 async function readFileContent(filePath, rootPath, fallbackRootPaths) {
   try {
     const fullPath = path3.resolve(resolveFilePath(filePath, rootPath, fallbackRootPaths));
-    if (!fs2.existsSync(fullPath)) {
+    if (!fs3.existsSync(fullPath)) {
       const roots = rootPath ? [rootPath, ...fallbackRootPaths] : fallbackRootPaths;
       return { success: false, error: `File not found: ${filePath} (roots: ${JSON.stringify(roots)})` };
     }
-    const stat = fs2.statSync(fullPath);
+    const stat = fs3.statSync(fullPath);
     if (stat.isDirectory()) {
-      const names = fs2.readdirSync(fullPath).sort();
-      const content2 = names.map((n) => fs2.statSync(path3.join(fullPath, n)).isDirectory() ? n + "/" : n).join(`
+      const names = fs3.readdirSync(fullPath).sort();
+      const content2 = names.map((n) => fs3.statSync(path3.join(fullPath, n)).isDirectory() ? n + "/" : n).join(`
 `);
       return { success: true, content: content2, fullPath, contentType: "text", isDirectory: true };
     }
-    if (stat.size > MAX_FILE_SIZE) {
+    const ext = path3.extname(fullPath).toLowerCase();
+    const isOffice = OFFICE_EXTENSIONS.has(ext);
+    const sizeLimit = isOffice ? MAX_OFFICE_FILE_SIZE : MAX_FILE_SIZE;
+    if (stat.size > sizeLimit) {
       return {
         success: false,
-        error: `File too large: ${fullPath} (${stat.size.toLocaleString()} bytes, max ${MAX_FILE_SIZE.toLocaleString()})`
+        error: `File too large: ${fullPath} (${stat.size.toLocaleString()} bytes, max ${sizeLimit.toLocaleString()})`
       };
     }
-    const content = fs2.readFileSync(fullPath, "utf-8");
+    if (ext === ".docx") {
+      const content2 = extractDocxContent(fullPath);
+      return { success: true, content: content2, fullPath, contentType: "docx-xml" };
+    }
+    if (ext === ".xlsx") {
+      const content2 = extractXlsxContent(fullPath);
+      return { success: true, content: content2, fullPath, contentType: "xlsx-xml" };
+    }
+    const content = fs3.readFileSync(fullPath, "utf-8");
     return { success: true, content, fullPath, contentType: "text" };
   } catch (e) {
     if (e instanceof WorkspacePathNotFoundError) {
@@ -4708,11 +6146,11 @@ async function readFileContent(filePath, rootPath, fallbackRootPaths) {
 // src/shell.ts
 import { spawn } from "child_process";
 import os3 from "os";
-import fs4 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 
 // src/tool-registry.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import os2 from "os";
 import path4 from "path";
 import { execSync, spawnSync } from "child_process";
@@ -4970,7 +6408,7 @@ function whichWithTools(name) {
     for (const ext of exts) {
       const full = path4.join(dir, name + ext);
       try {
-        fs3.accessSync(full, fs3.constants.X_OK);
+        fs4.accessSync(full, fs4.constants.X_OK);
         return full;
       } catch {}
     }
@@ -4979,7 +6417,8 @@ function whichWithTools(name) {
 }
 function findReferencedTools(content) {
   return Object.keys(TOOL_REGISTRY).filter((name) => {
-    const re = new RegExp("\\b" + name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\b");
+    const esc = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(String.raw`(?:^|[|;&\n]|&&|\|\||` + String.raw`\$\(|` + "`" + String.raw`|xargs\s+|sudo\s+|env\s+)\s*` + esc + String.raw`\b`, "m");
     return re.test(content);
   });
 }
@@ -4993,7 +6432,7 @@ async function installBinary(name) {
     return false;
   }
   const dir = binDir();
-  fs3.mkdirSync(dir, { recursive: true });
+  fs4.mkdirSync(dir, { recursive: true });
   const [url, isArchive] = await urlFunc();
   const destName = os2.platform() === "win32" ? `${name}.exe` : name;
   const dest = path4.join(dir, destName);
@@ -5003,7 +6442,7 @@ async function installBinary(name) {
   if (!res.ok)
     throw new Error(`Download failed: ${res.status}`);
   const data = Buffer.from(await res.arrayBuffer());
-  fs3.writeFileSync(tmpPath, data);
+  fs4.writeFileSync(tmpPath, data);
   if (isArchive) {
     const expectedNames = new Set([name, `${name}.exe`]);
     if (url.endsWith(".tar.gz") || url.endsWith(".tgz")) {
@@ -5013,41 +6452,41 @@ async function installBinary(name) {
     } else {
       throw new Error(`Unsupported archive: ${url}`);
     }
-    fs3.unlinkSync(tmpPath);
+    fs4.unlinkSync(tmpPath);
   } else {
-    fs3.renameSync(tmpPath, dest);
+    fs4.renameSync(tmpPath, dest);
   }
-  fs3.chmodSync(dest, 493);
+  fs4.chmodSync(dest, 493);
   return true;
 }
 async function extractTarBinary(archivePath, dest, expectedNames) {
   const tmpDir = dest + ".extract";
-  fs3.mkdirSync(tmpDir, { recursive: true });
+  fs4.mkdirSync(tmpDir, { recursive: true });
   try {
     execSync(`tar xzf "${archivePath}" -C "${tmpDir}"`, { stdio: "pipe" });
     const found = findFileRecursive(tmpDir, expectedNames);
     if (!found)
       throw new Error(`Binary not found in tar archive`);
-    fs3.copyFileSync(found, dest);
+    fs4.copyFileSync(found, dest);
   } finally {
-    fs3.rmSync(tmpDir, { recursive: true, force: true });
+    fs4.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 async function extractZipBinary(archivePath, dest, expectedNames) {
   const tmpDir = dest + ".extract";
-  fs3.mkdirSync(tmpDir, { recursive: true });
+  fs4.mkdirSync(tmpDir, { recursive: true });
   try {
     execSync(`unzip -o "${archivePath}" -d "${tmpDir}"`, { stdio: "pipe" });
     const found = findFileRecursive(tmpDir, expectedNames);
     if (!found)
       throw new Error(`Binary not found in zip archive`);
-    fs3.copyFileSync(found, dest);
+    fs4.copyFileSync(found, dest);
   } finally {
-    fs3.rmSync(tmpDir, { recursive: true, force: true });
+    fs4.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function findFileRecursive(dir, names) {
-  for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
     const full = path4.join(dir, entry.name);
     if (entry.isDirectory()) {
       const found = findFileRecursive(full, names);
@@ -5070,7 +6509,7 @@ function installWithNpm(name, pkg) {
 function installWithPip(name, pkg) {
   const venvDir = path4.join(TOOLS_DIR, "venv");
   const python = os2.platform() === "win32" ? path4.join(venvDir, "Scripts", "python.exe") : path4.join(venvDir, "bin", "python");
-  if (!fs3.existsSync(python)) {
+  if (!fs4.existsSync(python)) {
     log2("info", `Creating venv at ${venvDir}`);
     const py = whichWithTools("python3") || whichWithTools("python") || "python3";
     spawnSync(py, ["-m", "venv", venvDir], { stdio: "pipe" });
@@ -5105,7 +6544,7 @@ async function ensureTool(name) {
       return false;
     }
     log2("info", `Installing tool: ${name} (${pkg})`);
-    fs3.mkdirSync(TOOLS_DIR, { recursive: true });
+    fs4.mkdirSync(TOOLS_DIR, { recursive: true });
     await installFn(name, pkg);
     log2("info", `Successfully installed ${name}`);
     return true;
@@ -5118,6 +6557,38 @@ async function ensureTool(name) {
 }
 
 // src/shell.ts
+var IS_WIN = os3.platform() === "win32";
+function whichSync(name) {
+  const dirs = (process.env.PATH || "").split(path5.delimiter);
+  const exts = IS_WIN ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const full = path5.join(dir, name + ext);
+      try {
+        fs5.accessSync(full, fs5.constants.X_OK);
+        return full;
+      } catch {}
+    }
+  }
+  return null;
+}
+function getShellCommand(content) {
+  if (!IS_WIN)
+    return { shell: "/bin/bash", args: ["-c", content], prefix: "" };
+  const gitBash = "C:\\Program Files\\Git\\bin\\bash.exe";
+  if (fs5.existsSync(gitBash))
+    return { shell: gitBash, args: ["-c", content], prefix: "" };
+  const bashPath = whichSync("bash");
+  if (bashPath)
+    return { shell: bashPath, args: ["-c", content], prefix: "" };
+  const psPath = whichSync("powershell") || whichSync("pwsh");
+  if (psPath) {
+    const psPrefix = `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; $OutputEncoding = [System.Text.Encoding]::UTF8;
+`;
+    return { shell: psPath, args: ["-NoProfile", "-Command", psPrefix + content], prefix: "" };
+  }
+  return { shell: "cmd.exe", args: ["/c", "chcp 65001>nul && " + content], prefix: "" };
+}
 var ptySpawn = null;
 try {
   ptySpawn = require_lib().spawn;
@@ -5206,12 +6677,12 @@ async function executeBlock(blockId, content, send, todoId, messageId, timeout,
   outputBuffers.set(blockId, buf);
   try {
     const tmpDir = path5.join(os3.tmpdir(), "todoforai");
-    if (!fs4.existsSync(tmpDir))
-      fs4.mkdirSync(tmpDir, { recursive: true });
+    if (!fs5.existsSync(tmpDir))
+      fs5.mkdirSync(tmpDir, { recursive: true });
     let cwd = tmpDir;
     if (rootPath) {
       const expanded = rootPath.replace(/^~/, process.env.HOME || "~");
-      if (fs4.existsSync(expanded) && fs4.statSync(expanded).isDirectory())
+      if (fs5.existsSync(expanded) && fs5.statSync(expanded).isDirectory())
         cwd = expanded;
     }
     const missing = findMissingTools(content);
@@ -5272,8 +6743,9 @@ async function executeBlock(blockId, content, send, todoId, messageId, timeout,
       if (toStream)
         await send(msg.shellBlockResult(todoId, blockId, toStream, messageId));
     };
+    const sc = getShellCommand(content);
     if (ptySpawn) {
-      const pty = ptySpawn("/bin/bash", ["-c", content], {
+      const pty = ptySpawn(sc.shell, sc.args, {
         name: "xterm",
         cols: 200,
         rows: 50,
@@ -5286,10 +6758,10 @@ async function executeBlock(blockId, content, send, todoId, messageId, timeout,
       const timer = startTimeout();
       pty.onExit(async ({ exitCode }) => onExit(exitCode ?? -1, timer));
     } else {
-      const proc = spawn("/bin/bash", ["-c", content], {
+      const proc = spawn(sc.shell, sc.args, {
         cwd,
         stdio: ["pipe", "pipe", "pipe"],
-        detached: true,
+        detached: !IS_WIN,
         env
       });
       const handle = { child: proc, pid: proc.pid };
@@ -5298,8 +6770,8 @@ async function executeBlock(blockId, content, send, todoId, messageId, timeout,
       proc.stderr?.on("data", (d) => onData(d.toString("utf-8")));
       const timer = startTimeout();
       proc.on("close", (code) => onExit(code ?? -1, timer));
-      proc.on("error", (err) => {
-        send(msg.shellBlockResult(todoId, blockId, `Process error: ${err.message}`, messageId));
+      proc.on("error", (err2) => {
+        send(msg.shellBlockResult(todoId, blockId, `Process error: ${err2.message}`, messageId));
         onExit(-1, timer);
       });
     }
@@ -5349,6 +6821,8 @@ function interruptBlock(blockId) {
           } catch {}
         }, 500);
       }, 1000);
+    } else if (IS_WIN) {
+      handle.child?.kill();
     } else {
       process.kill(-handle.pid, "SIGINT");
     }
@@ -5383,7 +6857,7 @@ function clearBlockOutput(blockId) {
 }
 
 // src/functions.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path6 from "path";
 import os4 from "os";
 var FUNCTION_REGISTRY = new Map;
@@ -5405,7 +6879,7 @@ register("get_system_info", async () => {
     system2 = "macOS";
   else if (system2 === "linux") {
     try {
-      const release = fs5.readFileSync("/etc/os-release", "utf-8");
+      const release = fs6.readFileSync("/etc/os-release", "utf-8");
       const m = release.match(/PRETTY_NAME="(.+?)"/);
       if (m)
         system2 = m[1];
@@ -5420,6 +6894,113 @@ register("get_system_info", async () => {
   const shell = process.env.SHELL ? path6.basename(process.env.SHELL) : "unknown";
   return { system: system2, shell };
 });
+register("get_available_tools", async () => {
+  const tools = {};
+  for (const [name, [, type]] of Object.entries(TOOL_REGISTRY)) {
+    tools[name] = type;
+  }
+  return { tools };
+});
+register("get_workspace_tree", async (args) => {
+  const { path: p, max_depth = 2 } = args;
+  const root = path6.resolve(p.replace(/^~/, process.env.HOME || "~"));
+  if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) {
+    return { tree: "", is_git: false };
+  }
+  const isGit = fs6.existsSync(path6.join(root, ".git"));
+  if (process.platform !== "win32") {
+    try {
+      const { execSync: execSync2 } = await import("child_process");
+      execSync2("which tree", { encoding: "utf-8", stdio: "pipe" });
+      const cmd = ["tree", "-L", String(max_depth), "--dirsfirst"];
+      if (isGit)
+        cmd.push("--gitignore", "-I", ".git");
+      const result = execSync2(cmd.join(" "), {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: 5000,
+        maxBuffer: 1048576,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (result)
+        return { tree: result, is_git: isGit };
+    } catch {}
+  }
+  const ignore = (await Promise.resolve().then(() => __toESM(require_ignore(), 1))).default;
+  const ig = ignore();
+  if (isGit) {
+    let scanGitignores = function(dir) {
+      const giPath = path6.join(dir, ".gitignore");
+      if (fs6.existsSync(giPath)) {
+        try {
+          const relDir = path6.relative(root, dir).replace(/\\/g, "/");
+          const prefix = relDir === "" || relDir === "." ? "" : relDir + "/";
+          for (let line of fs6.readFileSync(giPath, "utf-8").split(`
+`)) {
+            line = line.trim();
+            if (!line || line.startsWith("#"))
+              continue;
+            if (prefix) {
+              ig.add(line.startsWith("!") ? "!" + prefix + line.slice(1) : prefix + line);
+            } else {
+              ig.add(line);
+            }
+          }
+        } catch {}
+      }
+      try {
+        for (const e of fs6.readdirSync(dir, { withFileTypes: true })) {
+          if (e.isDirectory() && e.name !== ".git")
+            scanGitignores(path6.join(dir, e.name));
+        }
+      } catch {}
+    };
+    scanGitignores(root);
+  }
+  const lines = [path6.basename(root) + "/"];
+  function walk(dirPath, prefix, depth) {
+    if (depth > max_depth)
+      return;
+    let entries;
+    try {
+      entries = fs6.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const visible = entries.filter((e) => {
+      if (e.name === ".git")
+        return false;
+      if (isGit) {
+        let rel = path6.relative(root, path6.join(dirPath, e.name)).replace(/\\/g, "/");
+        if (e.isDirectory())
+          rel += "/";
+        if (ig.ignores(rel))
+          return false;
+      }
+      return true;
+    }).sort((a, b) => {
+      const aDir = a.isDirectory() ? 0 : 1;
+      const bDir = b.isDirectory() ? 0 : 1;
+      if (aDir !== bDir)
+        return aDir - bDir;
+      return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+    });
+    for (let i2 = 0;i2 < visible.length; i2++) {
+      const entry = visible[i2];
+      const isLast = i2 === visible.length - 1;
+      const connector = isLast ? "└── " : "├── ";
+      const suffix = entry.isDirectory() ? "/" : "";
+      lines.push(`${prefix}${connector}${entry.name}${suffix}`);
+      if (entry.isDirectory()) {
+        const extension = isLast ? "    " : "│   ";
+        walk(path6.join(dirPath, entry.name), prefix + extension, depth + 1);
+      }
+    }
+  }
+  walk(root, "", 1);
+  return { tree: lines.join(`
+`), is_git: isGit };
+});
 register("get_os_aware_default_path", async () => {
   let p = getPlatformDefaultDirectory();
   if (!p.endsWith(path6.sep))
@@ -5434,8 +7015,8 @@ register("create_directory", async (args) => {
   let target = path6.resolve(name.replace(/^~/, process.env.HOME || "~"));
   if (!path6.isAbsolute(name))
     target = path6.join(baseDir, name.trim());
-  const existed = fs5.existsSync(target);
-  fs5.mkdirSync(target, { recursive: true });
+  const existed = fs6.existsSync(target);
+  fs6.mkdirSync(target, { recursive: true });
   let full = target;
   if (!full.endsWith(path6.sep))
     full += path6.sep;
@@ -5455,22 +7036,28 @@ register("execute_shell_command", async (args, client) => {
     });
     return { cmd, result };
   }
-  const send = (m) => client.sendResponse(m);
-  await send(msg.shellBlockStart(todoId, blockId, "execute", messageId));
-  await executeBlock(blockId, cmd, send, todoId, messageId, timeout, root_path, false, "internal");
-  if (pendingToolApprovals.has(blockId)) {
-    return { __awaiting_approval__: true };
-  }
-  await waitForCompletion(blockId, (timeout + 5) * 1000);
-  const output = getBlockOutput(blockId);
-  clearBlockOutput(blockId);
-  return { cmd, result: output };
+  try {
+    const send = (m) => client.sendResponse(m);
+    await send(msg.shellBlockStart(todoId, blockId, "execute", messageId));
+    await executeBlock(blockId, cmd, send, todoId, messageId, timeout, root_path, false, "internal");
+    if (pendingToolApprovals.has(blockId)) {
+      return { __awaiting_approval__: true };
+    }
+    await waitForCompletion(blockId, (timeout + 5) * 1000);
+    const output = getBlockOutput(blockId);
+    clearBlockOutput(blockId);
+    return { cmd, result: output };
+  } catch (e) {
+    throw e;
+  } finally {
+    clearBlockOutput(blockId);
+  }
 });
 register("read_file", async (args) => {
   const { path: p, rootPath = "", fallbackRootPaths = [] } = args;
   const result = await readFileContent(p, rootPath, fallbackRootPaths);
   if (!result.success)
-    throw new Error(result.error);
+    throw new Error(result.error || "Unknown read error");
   const { success, ...rest } = result;
   return rest;
 });
@@ -5479,23 +7066,23 @@ register("create_file", async (args) => {
   const fullPath = resolveFilePath(p, rootPath, fallbackRootPaths);
   const dir = path6.dirname(fullPath);
   if (dir)
-    fs5.mkdirSync(dir, { recursive: true });
-  fs5.writeFileSync(fullPath, content, "utf-8");
+    fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(fullPath, content, "utf-8");
   return { path: fullPath, bytes: Buffer.byteLength(content, "utf-8") };
 });
 register("read_file_base64", async (args) => {
   const { path: p, rootPath = "", fallbackRootPaths = [] } = args;
   const fullPath = resolveFilePath(p, rootPath, fallbackRootPaths);
-  if (!fs5.existsSync(fullPath))
+  if (!fs6.existsSync(fullPath))
     throw new Error(`File not found: ${fullPath}`);
-  const stat = fs5.statSync(fullPath);
+  const stat = fs6.statSync(fullPath);
   if (stat.size > 50000000)
     throw new Error(`File too large: ${stat.size.toLocaleString()} bytes (max 50MB)`);
-  const data = fs5.readFileSync(fullPath);
+  const data = fs6.readFileSync(fullPath);
   return { path: fullPath, base64: data.toString("base64"), bytes: data.length };
 });
 register("search_files", async (args) => {
-  const { pattern, path: p = ".", root_path = "", max_results = 100, glob: globPattern = "", ignore_case = true } = args;
+  const { pattern, path: p = ".", root_path = "", head = 100, max_count = 5, glob: globPattern = "", ignore_case = true } = args;
   const { execSync: execWhich } = await import("child_process");
   const which = (bin) => {
     try {
@@ -5515,30 +7102,39 @@ register("search_files", async (args) => {
   if (!path6.isAbsolute(searchPath) && root_path)
     searchPath = path6.join(root_path, searchPath);
   searchPath = path6.resolve(searchPath);
-  if (!fs5.existsSync(searchPath))
+  if (!fs6.existsSync(searchPath))
     throw new Error(`Search path does not exist: ${searchPath}`);
-  const cmd = [rgPath, "--no-heading", "--line-number", "--color=never", `--max-count=${max_results}`];
+  const cmd = [rgPath, "--no-heading", "--line-number", "--color=never"];
   if (ignore_case)
     cmd.push("--ignore-case");
+  if (max_count > 0)
+    cmd.push(`--max-count=${max_count}`);
   if (globPattern)
     cmd.push("--glob", globPattern);
   cmd.push(pattern, searchPath);
   const { spawn: spawnChild } = await import("child_process");
   const { stdout, stderr, code } = await new Promise((resolve) => {
     const child = spawnChild(cmd[0], cmd.slice(1));
-    let out = "", err = "";
+    let out = "", err2 = "";
     child.stdout?.on("data", (d) => {
       out += d.toString();
     });
     child.stderr?.on("data", (d) => {
-      err += d.toString();
+      err2 += d.toString();
     });
-    child.on("close", (exitCode) => resolve({ stdout: out, stderr: err, code: exitCode ?? 1 }));
+    child.on("close", (exitCode) => resolve({ stdout: out, stderr: err2, code: exitCode ?? 1 }));
   });
   if (code === 0) {
     let output = stdout;
+    const lines = output.split(`
+`).filter((l) => l.trim());
+    if (lines.length > head) {
+      output = lines.slice(0, head).join(`
+`) + `
+... (${lines.length - head} more matches truncated)`;
+    }
     if (root_path && output) {
-      const lines = output.split(`
+      const lines2 = output.split(`
 `).map((line) => {
         if (line.includes(":")) {
           const colonIdx = line.indexOf(":");
@@ -5559,7 +7155,7 @@ register("search_files", async (args) => {
         }
         return line;
       });
-      output = lines.join(`
+      output = lines2.join(`
 `);
     }
     if (output.length > 1e5)
@@ -5588,20 +7184,30 @@ register("download_attachment", async (args, client) => {
   if (!path6.isAbsolute(target))
     target = path6.join(base, target);
   target = path6.resolve(target);
-  fs5.mkdirSync(path6.dirname(target), { recursive: true });
-  const data = Buffer.from(await res.arrayBuffer());
-  fs5.writeFileSync(target, data);
-  return { path: target, bytes: data.length };
+  fs6.mkdirSync(path6.dirname(target), { recursive: true });
+  try {
+    const data = Buffer.from(await res.arrayBuffer());
+    fs6.writeFileSync(target, data);
+    return { path: target, bytes: data.length };
+  } catch (e) {
+    throw new Error(`Download failed: ${e.message}`);
+  }
 });
 register("download_chat", async (args, client) => {
   if (!client)
     throw new Error("Client instance required");
-  const res = await fetch(`${client.apiUrl.replace(/\/+$/, "")}/api/v1/todos/${args.todoId}`, {
-    headers: { "x-api-key": client.apiKey }
-  });
-  if (!res.ok)
-    throw new Error(`Backend responded with ${res.status}`);
-  return { todo: await res.json() };
+  try {
+    const res = await fetch(`${client.apiUrl.replace(/\/+$/, "")}/api/v1/todos/${args.todoId}`, {
+      headers: { "x-api-key": client.apiKey }
+    });
+    if (!res.ok)
+      throw new Error(`Backend responded with ${res.status}: ${await res.text()}`);
+    return { todo: await res.json() };
+  } catch (e) {
+    if (e instanceof Error)
+      throw e;
+    throw new Error(`Download chat failed: ${e.message}`);
+  }
 });
 register("register_attachment", async (args, client) => {
   if (!client)
@@ -5612,10 +7218,10 @@ register("register_attachment", async (args, client) => {
   if (!path6.isAbsolute(target))
     target = path6.join(base, target);
   target = path6.resolve(target);
-  if (!fs5.existsSync(target))
+  if (!fs6.existsSync(target))
     throw new Error(`File not found: ${target}`);
   const form = new FormData;
-  form.append("file", new Blob([fs5.readFileSync(target)]), path6.basename(target));
+  form.append("file", new Blob([fs6.readFileSync(target)]), path6.basename(target));
   if (userId)
     form.append("userId", userId);
   if (agentSettingsId)
@@ -5629,7 +7235,7 @@ register("register_attachment", async (args, client) => {
     body: form
   });
   if (!res.ok)
-    throw new Error(`Backend responded with ${res.status}`);
+    throw new Error(`Backend responded with ${res.status}: ${await res.text()}`);
   const payload = await res.json().catch(() => ({}));
   return { attachmentId: payload.attachmentId, response: payload };
 });
@@ -5656,10 +7262,21 @@ async function handleBlockSave(payload, send) {
   const { blockId, todoId, filepath, rootPath, fallbackRootPaths = [], content, requestId } = payload;
   try {
     const resolved = resolveFilePath(filepath, rootPath, fallbackRootPaths);
-    const dir = path7.dirname(resolved);
-    if (dir)
-      fs6.mkdirSync(dir, { recursive: true });
-    fs6.writeFileSync(resolved, content, "utf-8");
+    const ext = path7.extname(resolved).toLowerCase();
+    if (ext === ".docx" || ext === ".xlsx") {
+      if (!fs7.existsSync(resolved)) {
+        throw new Error(`Cannot create new ${ext} file from XML — file must already exist: ${filepath}`);
+      }
+      if (ext === ".docx")
+        saveDocxContent(resolved, content);
+      else
+        saveXlsxContent(resolved, content);
+    } else {
+      const dir = path7.dirname(resolved);
+      if (dir)
+        fs7.mkdirSync(dir, { recursive: true });
+      fs7.writeFileSync(resolved, content, "utf-8");
+    }
     await send(msg.blockSaveResult(blockId, todoId, "SUCCESS", requestId));
   } catch (e) {
     await send(msg.blockSaveResult(blockId, todoId, `ERROR: ${e.message}`, requestId));
@@ -5669,22 +7286,22 @@ async function handleGetFolders(payload, send) {
   const { requestId, edgeId } = payload;
   const rawPath = getPathOrDefault(payload.path);
   try {
+    const expandedPath = path7.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
     let targetPath;
-    if (rawPath.endsWith(path7.sep)) {
-      targetPath = rawPath.replace(/^~/, process.env.HOME || "~");
+    if (fs7.existsSync(expandedPath) && fs7.statSync(expandedPath).isDirectory()) {
+      targetPath = expandedPath;
     } else {
-      targetPath = path7.dirname(rawPath.replace(/^~/, process.env.HOME || "~"));
+      targetPath = path7.dirname(expandedPath);
     }
-    targetPath = path7.resolve(targetPath);
-    if (!fs6.existsSync(targetPath) || !fs6.statSync(targetPath).isDirectory()) {
+    if (!fs7.existsSync(targetPath) || !fs7.statSync(targetPath).isDirectory()) {
       throw new Error(`No existing ancestor for path: ${rawPath}`);
     }
     const folders = [];
     const files = [];
-    for (const item of fs6.readdirSync(targetPath)) {
+    for (const item of fs7.readdirSync(targetPath)) {
       const full = path7.join(targetPath, item);
       try {
-        if (fs6.statSync(full).isDirectory())
+        if (fs7.statSync(full).isDirectory())
           folders.push(full);
         else
           files.push(full);
@@ -5697,13 +7314,53 @@ async function handleGetFolders(payload, send) {
     await send(msg.getFoldersResponse(requestId, edgeId, [], [], e.message));
   }
 }
+async function handleCreateFolder(payload, send) {
+  const { requestId, edgeId, path: folderPath } = payload;
+  try {
+    await mkdir(folderPath, { recursive: true });
+    await send(msg.createFolderResponse(requestId, edgeId, true));
+  } catch (e) {
+    await send(msg.createFolderResponse(requestId, edgeId, false, e.message));
+  }
+}
+async function handleDeletePath(payload, send) {
+  const { requestId, edgeId, path: targetPath } = payload;
+  try {
+    await rm(targetPath, { recursive: true });
+    await send(msg.deletePathResponse(requestId, edgeId, true));
+  } catch (e) {
+    await send(msg.deletePathResponse(requestId, edgeId, false, e.message));
+  }
+}
+async function handleWriteFile(payload, send, pendingBinaries) {
+  const { requestId, edgeId, path: dirPath, fileName, binaryId, dataBase64 } = payload;
+  try {
+    const filePath = path7.join(dirPath, fileName);
+    const dir = path7.dirname(filePath);
+    if (dir)
+      fs7.mkdirSync(dir, { recursive: true });
+    let buffer;
+    if (binaryId && pendingBinaries?.has(binaryId)) {
+      buffer = pendingBinaries.get(binaryId);
+      pendingBinaries.delete(binaryId);
+    } else if (dataBase64) {
+      buffer = Buffer.from(dataBase64, "base64");
+    } else {
+      throw new Error("No file data provided (neither binaryId nor dataBase64)");
+    }
+    await writeFile(filePath, buffer);
+    await send(msg.writeFileResponse(requestId, edgeId, true));
+  } catch (e) {
+    await send(msg.writeFileResponse(requestId, edgeId, false, e.message));
+  }
+}
 var FORBIDDEN_PATHS = new Set(["/", "/tmp", "C:\\", "C:/"]);
 async function handleCd(payload, send, edgeConfig, onConfigChange) {
   const { requestId, edgeId } = payload;
   const rawPath = getPathOrDefault(payload.path);
   try {
     const resolved = path7.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
-    if (!fs6.existsSync(resolved) || !fs6.statSync(resolved).isDirectory()) {
+    if (!fs7.existsSync(resolved) || !fs7.statSync(resolved).isDirectory()) {
       throw new Error(`Path does not exist or is not a directory: ${rawPath}`);
     }
     const normalized = resolved.replace(/\/+$/, "");
@@ -5741,7 +7398,7 @@ async function handleFunctionCall(payload, send, client) {
     blockInfo = { todoId: args.todoId, messageId: args.messageId, blockId: args.blockId };
   }
   const makeSuccess = (result) => isAgent ? msg.functionCallResult(requestId, edgeId, true, result, undefined, agentId) : msg.functionCallResultFront(requestId, edgeId, true, result, undefined, blockInfo);
-  const makeError = (err) => isAgent ? msg.functionCallResult(requestId, edgeId, false, undefined, err, agentId) : msg.functionCallResultFront(requestId, edgeId, false, undefined, err, blockInfo);
+  const makeError = (err2) => isAgent ? msg.functionCallResult(requestId, edgeId, false, undefined, err2, agentId) : msg.functionCallResultFront(requestId, edgeId, false, undefined, err2, blockInfo);
   try {
     const fn = FUNCTION_REGISTRY.get(functionName);
     if (!fn) {
@@ -5761,11 +7418,11 @@ async function handleFunctionCall(payload, send, client) {
 // src/edge.ts
 function generateFingerprint() {
   const os5 = __require("os");
-  const fs7 = __require("fs");
+  const fs8 = __require("fs");
   const identifiers = {};
   if (process.platform === "linux") {
     try {
-      const mid = fs7.readFileSync("/etc/machine-id", "utf-8").trim();
+      const mid = fs8.readFileSync("/etc/machine-id", "utf-8").trim();
       if (mid)
         identifiers.machine_id = mid;
     } catch {}
@@ -5860,6 +7517,10 @@ class TODOforAIEdge {
     const frontendUrl = this.api.apiUrl.replace("://api.", "://");
     console.log(`\x1B[33mPlease provide your API key\x1B[0m`);
     console.log(`\x1B[36mGet one at: ${frontendUrl}/apikey\x1B[0m`);
+    if (!process.stdin.isTTY) {
+      console.error("No API key provided and stdin is not interactive. Set TODOFORAI_API_KEY or pass --api-key.");
+      process.exit(1);
+    }
     const rl = __require("readline").createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
       const ask = () => {
@@ -5923,6 +7584,17 @@ class TODOforAIEdge {
       }
     }
   }
+  pendingBinaries = new Map;
+  storeBinaryFrame(frame) {
+    if (frame.length < 36)
+      return;
+    let id = "";
+    for (let i2 = 0;i2 < 36; i2++)
+      id += String.fromCharCode(frame[i2]);
+    const data = frame.slice(36);
+    this.pendingBinaries.set(id, data);
+    setTimeout(() => this.pendingBinaries.delete(id), 60000);
+  }
   async handleMessage(raw) {
     let data;
     try {
@@ -5986,6 +7658,15 @@ class TODOforAIEdge {
       case FE.GET_FOLDERS:
         run(() => handleGetFolders(payload, send));
         break;
+      case FE.EDGE_CREATE_FOLDER:
+        run(() => handleCreateFolder(payload, send));
+        break;
+      case FE.EDGE_DELETE_PATH:
+        run(() => handleDeletePath(payload, send));
+        break;
+      case FE.EDGE_WRITE_FILE:
+        run(() => handleWriteFile(payload, send, this.pendingBinaries));
+        break;
       case AE.FUNCTION_CALL_REQUEST_AGENT:
       case FE.FUNCTION_CALL_REQUEST_FRONT:
         run(() => handleFunctionCall(payload, send, this));
@@ -6008,7 +7689,12 @@ class TODOforAIEdge {
         this.connected = true;
         console.log("[info] WebSocket connected");
       });
-      this.ws.on("message", (data) => {
+      this.ws.on("message", (data, isBinary) => {
+        if (isBinary) {
+          const frame = data instanceof Buffer ? new Uint8Array(data) : new Uint8Array(data);
+          this.storeBinaryFrame(frame);
+          return;
+        }
         this.handleMessage(data.toString()).catch((e) => {
           if (e instanceof AuthenticationError || e instanceof ServerError) {
             this.ws?.close();
@@ -6023,10 +7709,10 @@ class TODOforAIEdge {
         this.ws = null;
         resolve();
       });
-      this.ws.on("error", (err) => {
+      this.ws.on("error", (err2) => {
         this.connected = false;
         this.ws = null;
-        reject(err);
+        reject(err2);
       });
     });
   }