@todoforai/edge 0.13.13 → 0.13.14

package/dist/index.js

@@ -47695,7 +47695,7 @@ var require_ignore = __commonJS((exports, module) => {
       makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
       return this._added;
     }
-    test(path7, checkUnignored, mode) {
+    test(path8, checkUnignored, mode) {
       let ignored = false;
       let unignored = false;
       let matchedRule;
@@ -47704,7 +47704,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule[mode].test(path7);
+        const matched = rule[mode].test(path8);
         if (!matched) {
           return;
         }
@@ -47725,20 +47725,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path7, originalPath, doThrow) => {
-    if (!isString(path7)) {
+  var checkPath = (path8, originalPath, doThrow) => {
+    if (!isString(path8)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path7) {
+    if (!path8) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path7)) {
+    if (checkPath.isNotRelative(path8)) {
       const r = "`path.relative()`d";
       return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+  var isNotRelative = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p10) => p10;
 
@@ -47767,15 +47767,15 @@ var require_ignore = __commonJS((exports, module) => {
       return this.add(pattern);
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path7 = originalPath && checkPath.convert(originalPath);
-      checkPath(path7, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
-      return this._t(path7, cache, checkUnignored, slices);
+      const path8 = originalPath && checkPath.convert(originalPath);
+      checkPath(path8, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path8, cache, checkUnignored, slices);
     }
-    checkIgnore(path7) {
-      if (!REGEX_TEST_TRAILING_SLASH.test(path7)) {
-        return this.test(path7);
+    checkIgnore(path8) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path8)) {
+        return this.test(path8);
       }
-      const slices = path7.split(SLASH).filter(Boolean);
+      const slices = path8.split(SLASH).filter(Boolean);
       slices.pop();
       if (slices.length) {
         const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
@@ -47783,42 +47783,42 @@ var require_ignore = __commonJS((exports, module) => {
           return parent;
         }
       }
-      return this._rules.test(path7, false, MODE_CHECK_IGNORE);
+      return this._rules.test(path8, false, MODE_CHECK_IGNORE);
     }
-    _t(path7, cache, checkUnignored, slices) {
-      if (path7 in cache) {
-        return cache[path7];
+    _t(path8, cache, checkUnignored, slices) {
+      if (path8 in cache) {
+        return cache[path8];
       }
       if (!slices) {
-        slices = path7.split(SLASH).filter(Boolean);
+        slices = path8.split(SLASH).filter(Boolean);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path7] = this._rules.test(path7, checkUnignored, MODE_IGNORE);
+        return cache[path8] = this._rules.test(path8, checkUnignored, MODE_IGNORE);
       }
       const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-      return cache[path7] = parent.ignored ? parent : this._rules.test(path7, checkUnignored, MODE_IGNORE);
+      return cache[path8] = parent.ignored ? parent : this._rules.test(path8, checkUnignored, MODE_IGNORE);
     }
-    ignores(path7) {
-      return this._test(path7, this._ignoreCache, false).ignored;
+    ignores(path8) {
+      return this._test(path8, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path7) => !this.ignores(path7);
+      return (path8) => !this.ignores(path8);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path7) {
-      return this._test(path7, this._testCache, true);
+    test(path8) {
+      return this._test(path8, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore(options);
-  var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+  var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, 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 = (path7) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+    checkPath.isNotRelative = (path8) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
   };
   if (typeof process !== "undefined" && process.platform === "win32") {
     setupWindows();
@@ -48645,9 +48645,9 @@ class BrowserExtensionBridge {
 }
 
 // src/handlers.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import { mkdir, rm as rm2, writeFile } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 
 // src/path-utils.ts
 import path2 from "path";
@@ -49091,7 +49091,6 @@ var tool_catalog_default = {
     label: "TODOforAI",
     capabilities: "Create & manage TODOs, run workflows, API access",
     description: "Use to programmatically create/list/update TODOs in TODOforAI, kick off workflows, call the platform API.",
-    statusCmd: "todoai whoami >/dev/null 2>&1",
     installCmd: "bun add -g @todoforai/cli",
     versionCmd: "todoai --version 2>/dev/null | head -1",
     internal: true
@@ -51889,9 +51888,9 @@ function consumeExitedOutput(pid) {
 }
 
 // src/functions.ts
-import fs10 from "fs";
-import path7 from "path";
-import os8 from "os";
+import fs11 from "fs";
+import path8 from "path";
+import os9 from "os";
 
 // src/skills.ts
 import fs9 from "fs";
@@ -52068,6 +52067,62 @@ function sanitize(s) {
   return s.split(/\s+/).filter(Boolean).join(" ");
 }
 
+// src/agent-md.ts
+import fs10 from "fs";
+import path7 from "path";
+import os8 from "os";
+var MAX_BYTES = 64 * 1024;
+var FILENAMES = ["AGENT.md", "AGENTS.md"];
+async function discoverAgentMd(rootPaths, opts = {}) {
+  const includeUserScope = opts.includeUserScope ?? true;
+  const maxBytes = opts.maxBytes ?? MAX_BYTES;
+  const dirs = [
+    ...rootPaths.map((p10) => ({ dir: p10, scope: "repo" }))
+  ];
+  if (includeUserScope) {
+    dirs.push({ dir: path7.join(os8.homedir(), ".agents"), scope: "user" });
+  }
+  const files = [];
+  const errors = [];
+  const seen = new Set;
+  for (const { dir, scope } of dirs) {
+    for (const name of FILENAMES) {
+      const full = path7.join(dir, name);
+      if (seen.has(full))
+        continue;
+      let stat;
+      try {
+        stat = fs10.statSync(full);
+      } catch {
+        continue;
+      }
+      if (!stat.isFile())
+        continue;
+      seen.add(full);
+      try {
+        const fd3 = fs10.openSync(full, "r");
+        const buf = Buffer.alloc(maxBytes);
+        let bytes;
+        try {
+          bytes = fs10.readSync(fd3, buf, 0, maxBytes, 0);
+        } finally {
+          fs10.closeSync(fd3);
+        }
+        files.push({
+          path: full,
+          scope,
+          content: buf.subarray(0, bytes).toString("utf-8"),
+          bytes: stat.size,
+          truncated: stat.size > maxBytes
+        });
+      } catch (e) {
+        errors.push({ path: full, message: `read failed: ${e?.message ?? e}` });
+      }
+    }
+  }
+  return { files, errors };
+}
+
 // src/functions.ts
 var FUNCTION_REGISTRY = new Map;
 function register(name, fn2) {
@@ -52083,12 +52138,12 @@ register("get_environment_variable", async (args) => ({
   value: process.env[args.var_name] ?? null
 }));
 register("get_system_info", async () => {
-  let system2 = os8.platform();
+  let system2 = os9.platform();
   if (system2 === "darwin")
     system2 = "macOS";
   else if (system2 === "linux") {
     try {
-      const release = fs10.readFileSync("/etc/os-release", "utf-8");
+      const release = fs11.readFileSync("/etc/os-release", "utf-8");
       const m = release.match(/PRETTY_NAME="(.+?)"/);
       if (m)
         system2 = m[1];
@@ -52098,10 +52153,10 @@ register("get_system_info", async () => {
       system2 = "Linux";
     }
   } else if (system2 === "win32") {
-    system2 = `Windows ${os8.release()}`;
+    system2 = `Windows ${os9.release()}`;
   }
-  const shell = process.env.SHELL ? path7.basename(process.env.SHELL) : "unknown";
-  const mount_path = path7.join(os8.homedir(), ".todoforai", "mnt", "todoforai");
+  const shell = process.env.SHELL ? path8.basename(process.env.SHELL) : "unknown";
+  const mount_path = path8.join(os9.homedir(), ".todoforai", "mnt", "todoforai");
   return { system: system2, shell, mount_path };
 });
 register("get_available_tools", async () => {
@@ -52145,11 +52200,11 @@ register("uninstall_tool", async (args) => {
 });
 register("get_workspace_tree", async (args) => {
   const { path: p10, max_depth = 2 } = args;
-  const root = path7.resolve(p10.replace(/^~/, process.env.HOME || "~"));
-  if (!fs10.existsSync(root) || !fs10.statSync(root).isDirectory()) {
+  const root = path8.resolve(p10.replace(/^~/, process.env.HOME || "~"));
+  if (!fs11.existsSync(root) || !fs11.statSync(root).isDirectory()) {
     return { tree: "", is_git: false };
   }
-  const isGit = fs10.existsSync(path7.join(root, ".git"));
+  const isGit = fs11.existsSync(path8.join(root, ".git"));
   if (process.platform !== "win32") {
     try {
       const { execSync: execSync2 } = await import("child_process");
@@ -52172,12 +52227,12 @@ register("get_workspace_tree", async (args) => {
   const ig2 = ignore();
   if (isGit) {
     let scanGitignores = function(dir) {
-      const giPath = path7.join(dir, ".gitignore");
-      if (fs10.existsSync(giPath)) {
+      const giPath = path8.join(dir, ".gitignore");
+      if (fs11.existsSync(giPath)) {
         try {
-          const relDir = path7.relative(root, dir).replace(/\\/g, "/");
+          const relDir = path8.relative(root, dir).replace(/\\/g, "/");
           const prefix = relDir === "" || relDir === "." ? "" : relDir + "/";
-          for (let line of fs10.readFileSync(giPath, "utf-8").split(`
+          for (let line of fs11.readFileSync(giPath, "utf-8").split(`
 `)) {
             line = line.trim();
             if (!line || line.startsWith("#"))
@@ -52191,21 +52246,21 @@ register("get_workspace_tree", async (args) => {
         } catch {}
       }
       try {
-        for (const e of fs10.readdirSync(dir, { withFileTypes: true })) {
+        for (const e of fs11.readdirSync(dir, { withFileTypes: true })) {
           if (e.isDirectory() && e.name !== ".git")
-            scanGitignores(path7.join(dir, e.name));
+            scanGitignores(path8.join(dir, e.name));
         }
       } catch {}
     };
     scanGitignores(root);
   }
-  const lines = [path7.basename(root) + "/"];
+  const lines = [path8.basename(root) + "/"];
   function walk(dirPath, prefix, depth) {
     if (depth > max_depth)
       return;
     let entries;
     try {
-      entries = fs10.readdirSync(dirPath, { withFileTypes: true });
+      entries = fs11.readdirSync(dirPath, { withFileTypes: true });
     } catch {
       return;
     }
@@ -52213,7 +52268,7 @@ register("get_workspace_tree", async (args) => {
       if (e.name === ".git")
         return false;
       if (isGit) {
-        let rel = path7.relative(root, path7.join(dirPath, e.name)).replace(/\\/g, "/");
+        let rel = path8.relative(root, path8.join(dirPath, e.name)).replace(/\\/g, "/");
         if (e.isDirectory())
           rel += "/";
         if (ig2.ignores(rel))
@@ -52235,7 +52290,7 @@ register("get_workspace_tree", async (args) => {
       lines.push(`${prefix}${connector}${entry.name}${suffix}`);
       if (entry.isDirectory()) {
         const extension2 = isLast ? "    " : "│   ";
-        walk(path7.join(dirPath, entry.name), prefix + extension2, depth + 1);
+        walk(path8.join(dirPath, entry.name), prefix + extension2, depth + 1);
       }
     }
   }
@@ -52248,25 +52303,30 @@ register("get_skills", async (args) => {
   const includeUserScope = args?.includeUserScope ?? true;
   return await discoverSkills(paths, { includeUserScope });
 });
+register("get_agent_md", async (args) => {
+  const paths = Array.isArray(args?.paths) ? args.paths : [];
+  const includeUserScope = args?.includeUserScope ?? true;
+  return await discoverAgentMd(paths, { includeUserScope });
+});
 register("get_os_aware_default_path", async () => {
   let p10 = getPlatformDefaultDirectory();
-  if (!p10.endsWith(path7.sep))
-    p10 += path7.sep;
+  if (!p10.endsWith(path8.sep))
+    p10 += path8.sep;
   return { path: p10 };
 });
 register("create_directory", async (args) => {
   const { name } = args;
   if (!name?.trim())
     throw new Error("Folder name cannot be empty");
-  const baseDir = path7.resolve(getPathOrDefault(args.path).replace(/^~/, process.env.HOME || "~"));
-  let target = path7.resolve(name.replace(/^~/, process.env.HOME || "~"));
-  if (!path7.isAbsolute(name))
-    target = path7.join(baseDir, name.trim());
-  const existed = fs10.existsSync(target);
-  fs10.mkdirSync(target, { recursive: true });
+  const baseDir = path8.resolve(getPathOrDefault(args.path).replace(/^~/, process.env.HOME || "~"));
+  let target = path8.resolve(name.replace(/^~/, process.env.HOME || "~"));
+  if (!path8.isAbsolute(name))
+    target = path8.join(baseDir, name.trim());
+  const existed = fs11.existsSync(target);
+  fs11.mkdirSync(target, { recursive: true });
   let full = target;
-  if (!full.endsWith(path7.sep))
-    full += path7.sep;
+  if (!full.endsWith(path8.sep))
+    full += path8.sep;
   return { path: full, created: !existed, exists: true };
 });
 FUNCTION_REGISTRY.set("getOSAwareDefaultPath", FUNCTION_REGISTRY.get("get_os_aware_default_path"));
@@ -52300,7 +52360,7 @@ register("execute_shell_command", async (args, client) => {
   if (!canStream) {
     const { exec } = await import("child_process");
     const result = await new Promise((resolve) => {
-      exec(cmd, { cwd: cwd || os8.tmpdir(), encoding: "utf-8", timeout: timeout * 1000, maxBuffer: 10485760, env: { ...buildEnvWithTools(), ...getConnectionEnv(), TODOFORAI_TODO_ID: todoId, TODOFORAI_MESSAGE_ID: messageId, TODOFORAI_BLOCK_ID: blockId, TODOFORAI_AGENT_SETTINGS_ID: agentSettingsId } }, (_err, stdout, stderr) => {
+      exec(cmd, { cwd: cwd || os9.tmpdir(), encoding: "utf-8", timeout: timeout * 1000, maxBuffer: 10485760, env: { ...buildEnvWithTools(), ...getConnectionEnv(), TODOFORAI_TODO_ID: todoId, TODOFORAI_MESSAGE_ID: messageId, TODOFORAI_BLOCK_ID: blockId, TODOFORAI_AGENT_SETTINGS_ID: agentSettingsId } }, (_err, stdout, stderr) => {
         resolve((stdout || "") + (stderr || ""));
       });
     });
@@ -52365,17 +52425,17 @@ var LIST_DIR_MAX_ENTRIES = 1e4;
 register("list_dir", async (args) => {
   const { path: p10, rootPath = "", fallbackRootPaths = [] } = args;
   const fullPath = resolveFilePath(p10, rootPath, fallbackRootPaths);
-  const st2 = fs10.statSync(fullPath);
+  const st2 = fs11.statSync(fullPath);
   if (!st2.isDirectory())
     throw new Error(`Not a directory: ${fullPath}`);
-  const dirents = fs10.readdirSync(fullPath, { withFileTypes: true });
+  const dirents = fs11.readdirSync(fullPath, { withFileTypes: true });
   if (dirents.length > LIST_DIR_MAX_ENTRIES) {
     throw new Error(`Directory too large: ${dirents.length} entries (max ${LIST_DIR_MAX_ENTRIES})`);
   }
   const entries = dirents.map((d) => {
     let size = 0, mtime = 0, mode = 0, is_dir = d.isDirectory();
     try {
-      const s = fs10.lstatSync(path7.join(fullPath, d.name));
+      const s = fs11.lstatSync(path8.join(fullPath, d.name));
       size = Number(s.size);
       mtime = s.mtimeMs / 1000;
       mode = s.mode & 511;
@@ -52388,21 +52448,21 @@ register("list_dir", async (args) => {
 register("create_file", async (args) => {
   const { path: p10, content, rootPath = "", fallbackRootPaths = [] } = args;
   const fullPath = resolveFilePath(p10, rootPath, fallbackRootPaths);
-  const dir = path7.dirname(fullPath);
+  const dir = path8.dirname(fullPath);
   if (dir)
-    fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(fullPath, content, "utf-8");
+    fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(fullPath, content, "utf-8");
   return { path: fullPath, bytes: Buffer.byteLength(content, "utf-8") };
 });
 register("read_file_base64", async (args) => {
   const { path: p10, rootPath = "", fallbackRootPaths = [] } = args;
   const fullPath = resolveFilePath(p10, rootPath, fallbackRootPaths);
-  if (!fs10.existsSync(fullPath))
+  if (!fs11.existsSync(fullPath))
     throw new Error(`File not found: ${fullPath}`);
-  const stat = fs10.statSync(fullPath);
+  const stat = fs11.statSync(fullPath);
   if (stat.size > 50000000)
     throw new Error(`File too large: ${stat.size.toLocaleString()} bytes (max 50MB)`);
-  const data = fs10.readFileSync(fullPath);
+  const data = fs11.readFileSync(fullPath);
   return { path: fullPath, base64: data.toString("base64"), bytes: data.length };
 });
 register("download_attachment", async (args, client) => {
@@ -52419,13 +52479,13 @@ register("download_attachment", async (args, client) => {
     throw new Error(`Backend responded with ${res.status}`);
   const base = getPathOrDefault(rootPath);
   let target = p10.replace(/^~/, process.env.HOME || "~");
-  if (!path7.isAbsolute(target))
-    target = path7.join(base, target);
-  target = path7.resolve(target);
-  fs10.mkdirSync(path7.dirname(target), { recursive: true });
+  if (!path8.isAbsolute(target))
+    target = path8.join(base, target);
+  target = path8.resolve(target);
+  fs11.mkdirSync(path8.dirname(target), { recursive: true });
   try {
     const data = Buffer.from(await res.arrayBuffer());
-    fs10.writeFileSync(target, data);
+    fs11.writeFileSync(target, data);
     return { path: target, bytes: data.length };
   } catch (e) {
     throw new Error(`Download failed: ${e.message}`);
@@ -52453,13 +52513,13 @@ register("register_attachment", async (args, client) => {
   const { filePath, userId = "test-user", isPublic = false, agentSettingsId = "", todoId = "", rootPath = "" } = args;
   const base = getPathOrDefault(rootPath);
   let target = filePath.replace(/^~/, process.env.HOME || "~");
-  if (!path7.isAbsolute(target))
-    target = path7.join(base, target);
-  target = path7.resolve(target);
-  if (!fs10.existsSync(target))
+  if (!path8.isAbsolute(target))
+    target = path8.join(base, target);
+  target = path8.resolve(target);
+  if (!fs11.existsSync(target))
     throw new Error(`File not found: ${target}`);
   const form = new FormData;
-  form.append("file", new Blob([fs10.readFileSync(target)]), path7.basename(target));
+  form.append("file", new Blob([fs11.readFileSync(target)]), path8.basename(target));
   if (userId)
     form.append("userId", userId);
   if (agentSettingsId)
@@ -52503,9 +52563,9 @@ async function handleBlockSave(payload, send) {
   const { blockId, todoId, filepath, rootPath, fallbackRootPaths = [], content, requestId } = payload;
   try {
     const resolved = resolveFilePath(filepath, rootPath, fallbackRootPaths);
-    const ext = path8.extname(resolved).toLowerCase();
+    const ext = path9.extname(resolved).toLowerCase();
     if (ext === ".docx" || ext === ".xlsx") {
-      if (!fs11.existsSync(resolved)) {
+      if (!fs12.existsSync(resolved)) {
         throw new Error(`Cannot create new ${ext} file from XML — file must already exist: ${filepath}`);
       }
       if (ext === ".docx")
@@ -52513,10 +52573,10 @@ async function handleBlockSave(payload, send) {
       else
         saveXlsxContent(resolved, content);
     } else {
-      const dir = path8.dirname(resolved);
+      const dir = path9.dirname(resolved);
       if (dir)
-        fs11.mkdirSync(dir, { recursive: true });
-      fs11.writeFileSync(resolved, content, "utf-8");
+        fs12.mkdirSync(dir, { recursive: true });
+      fs12.writeFileSync(resolved, content, "utf-8");
     }
     await send(msg.blockSaveResult(blockId, todoId, "SUCCESS", requestId));
   } catch (e) {
@@ -52527,22 +52587,22 @@ async function handleGetFolders(payload, send) {
   const { requestId, edgeId } = payload;
   const rawPath = getPathOrDefault(payload.path);
   try {
-    const expandedPath = path8.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
+    const expandedPath = path9.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
     let targetPath;
-    if (fs11.existsSync(expandedPath) && fs11.statSync(expandedPath).isDirectory()) {
+    if (fs12.existsSync(expandedPath) && fs12.statSync(expandedPath).isDirectory()) {
       targetPath = expandedPath;
     } else {
-      targetPath = path8.dirname(expandedPath);
+      targetPath = path9.dirname(expandedPath);
     }
-    if (!fs11.existsSync(targetPath) || !fs11.statSync(targetPath).isDirectory()) {
+    if (!fs12.existsSync(targetPath) || !fs12.statSync(targetPath).isDirectory()) {
       throw new Error(`No existing ancestor for path: ${rawPath}`);
     }
     const folders = [];
     const files = [];
-    for (const item of fs11.readdirSync(targetPath)) {
-      const full = path8.join(targetPath, item);
+    for (const item of fs12.readdirSync(targetPath)) {
+      const full = path9.join(targetPath, item);
       try {
-        if (fs11.statSync(full).isDirectory())
+        if (fs12.statSync(full).isDirectory())
           folders.push(full);
         else
           files.push(full);
@@ -52576,10 +52636,10 @@ async function handleDeletePath(payload, send) {
 async function handleWriteFile(payload, send, pendingBinaries) {
   const { requestId, edgeId, path: dirPath, fileName, binaryId, dataBase64 } = payload;
   try {
-    const filePath = path8.join(dirPath, fileName);
-    const dir = path8.dirname(filePath);
+    const filePath = path9.join(dirPath, fileName);
+    const dir = path9.dirname(filePath);
     if (dir)
-      fs11.mkdirSync(dir, { recursive: true });
+      fs12.mkdirSync(dir, { recursive: true });
     let buffer;
     if (binaryId && pendingBinaries?.has(binaryId)) {
       buffer = pendingBinaries.get(binaryId);
@@ -52600,8 +52660,8 @@ async function handleCd(payload, send, edgeConfig, onConfigChange) {
   const { requestId, edgeId } = payload;
   const rawPath = getPathOrDefault(payload.path);
   try {
-    const resolved = path8.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
-    if (!fs11.existsSync(resolved) || !fs11.statSync(resolved).isDirectory()) {
+    const resolved = path9.resolve(rawPath.replace(/^~/, process.env.HOME || "~"));
+    if (!fs12.existsSync(resolved) || !fs12.statSync(resolved).isDirectory()) {
       throw new Error(`Path does not exist or is not a directory: ${rawPath}`);
     }
     const normalized = resolved.replace(/\/+$/, "");
@@ -52656,12 +52716,12 @@ async function handleFunctionCall(payload, send, client) {
 
 // src/edge.ts
 function generateFingerprint() {
-  const os9 = __require("os");
-  const fs12 = __require("fs");
+  const os10 = __require("os");
+  const fs13 = __require("fs");
   const identifiers = {};
   if (process.platform === "linux") {
     try {
-      const mid = fs12.readFileSync("/etc/machine-id", "utf-8").trim();
+      const mid = fs13.readFileSync("/etc/machine-id", "utf-8").trim();
       if (mid)
         identifiers.machine_id = mid;
     } catch {}
@@ -52676,8 +52736,8 @@ function generateFingerprint() {
   }
   if (Object.keys(identifiers).length === 0) {
     identifiers.platform = process.platform;
-    identifiers.machine = os9.machine?.() || os9.arch();
-    identifiers.node = os9.hostname();
+    identifiers.machine = os10.machine?.() || os10.arch();
+    identifiers.node = os10.hostname();
   }
   const keys = Object.keys(identifiers).sort();
   const json = "{" + keys.map((k) => JSON.stringify(k) + ": " + JSON.stringify(identifiers[k])).join(", ") + "}";
@@ -52863,8 +52923,8 @@ class TODOforAIEdge {
     if (edgeId && edgeId !== this.edgeId)
       return;
     if (payload.workspacepaths) {
-      const path9 = __require("path");
-      payload.workspacepaths = payload.workspacepaths.filter((p10) => !FORBIDDEN_PATHS2.has(path9.normalize(p10).replace(/\/+$/, "")));
+      const path10 = __require("path");
+      payload.workspacepaths = payload.workspacepaths.filter((p10) => !FORBIDDEN_PATHS2.has(path10.normalize(p10).replace(/\/+$/, "")));
     }
     Object.assign(this.edgeConfig, payload);
     if (this.addWorkspacePath) {
@@ -53146,18 +53206,18 @@ class ServerError extends Error {
 }
 
 // node_modules/@todoforai/update-notifier/src/index.ts
-import fs12 from "node:fs";
-import path9 from "node:path";
-import os9 from "node:os";
+import fs13 from "node:fs";
+import path10 from "node:path";
+import os10 from "node:os";
 function isLinkedInstall() {
   try {
-    return !fs12.realpathSync(process.argv[1] || "").includes(`${path9.sep}node_modules${path9.sep}`);
+    return !fs13.realpathSync(process.argv[1] || "").includes(`${path10.sep}node_modules${path10.sep}`);
   } catch {
     return false;
   }
 }
 var TTL_MS = 24 * 60 * 60 * 1000;
-var CACHE_DIR = path9.join(os9.homedir(), ".config", "todoforai");
+var CACHE_DIR = path10.join(os10.homedir(), ".config", "todoforai");
 function cmpVer(a, b) {
   const pa2 = a.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
   const pb2 = b.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
@@ -53171,10 +53231,10 @@ function cmpVer(a, b) {
 function checkForUpdates(pkg) {
   if (!process.stderr.isTTY || process.env.CI || process.env.NO_UPDATE_NOTIFIER || isLinkedInstall())
     return;
-  const cacheFile = path9.join(CACHE_DIR, `notifier-${encodeURIComponent(pkg.name)}.json`);
+  const cacheFile = path10.join(CACHE_DIR, `notifier-${encodeURIComponent(pkg.name)}.json`);
   let cache = {};
   try {
-    cache = JSON.parse(fs12.readFileSync(cacheFile, "utf8"));
+    cache = JSON.parse(fs13.readFileSync(cacheFile, "utf8"));
   } catch {}
   if (cache.latest && cmpVer(cache.latest, pkg.version) > 0) {
     process.stderr.write(`
@@ -53185,42 +53245,42 @@ function checkForUpdates(pkg) {
   }
   if (Date.now() - (cache.ts ?? 0) > TTL_MS) {
     try {
-      fs12.mkdirSync(CACHE_DIR, { recursive: true });
-      fs12.writeFileSync(cacheFile, JSON.stringify({ ...cache, ts: Date.now() }));
+      fs13.mkdirSync(CACHE_DIR, { recursive: true });
+      fs13.writeFileSync(cacheFile, JSON.stringify({ ...cache, ts: Date.now() }));
     } catch {}
     fetch(`https://registry.npmjs.org/${pkg.name}/latest`, { signal: AbortSignal.timeout(3000) }).then((r) => r.ok ? r.json() : null).then((j) => {
       if (!j?.version)
         return;
-      fs12.writeFileSync(cacheFile, JSON.stringify({ ts: Date.now(), latest: j.version }));
+      fs13.writeFileSync(cacheFile, JSON.stringify({ ts: Date.now(), latest: j.version }));
     }).catch(() => {});
   }
 }
 
 // src/index.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
-import fs13 from "fs";
-import path10 from "path";
-import os10 from "os";
+import fs14 from "fs";
+import path11 from "path";
+import os11 from "os";
 import crypto3 from "crypto";
 function readOwnPackage() {
   try {
-    const pkgPath = path10.resolve(fileURLToPath2(import.meta.url), "../../package.json");
-    return JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path11.resolve(fileURLToPath2(import.meta.url), "../../package.json");
+    return JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function lockPath(apiUrl, userId) {
-  const dir = path10.join(os10.homedir(), ".todoforai");
-  fs13.mkdirSync(dir, { recursive: true });
+  const dir = path11.join(os11.homedir(), ".todoforai");
+  fs14.mkdirSync(dir, { recursive: true });
   const hash = crypto3.createHash("sha256").update(`${apiUrl}
 ${userId}`).digest("hex").slice(0, 12);
-  return path10.join(dir, `edge-${hash}.lock`);
+  return path11.join(dir, `edge-${hash}.lock`);
 }
 function isEdgeProcess(pid) {
   try {
     process.kill(pid, 0);
-    const cmdline = fs13.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
+    const cmdline = fs14.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
     return cmdline.includes("index.ts") || cmdline.includes("todoforai-edge");
   } catch {
     return false;
@@ -53228,7 +53288,7 @@ function isEdgeProcess(pid) {
 }
 function killExistingEdge(lp2) {
   try {
-    const pid = parseInt(fs13.readFileSync(lp2, "utf-8").trim(), 10);
+    const pid = parseInt(fs14.readFileSync(lp2, "utf-8").trim(), 10);
     if (!isNaN(pid) && isEdgeProcess(pid)) {
       console.log(`\x1B[33mKilling existing edge process (pid ${pid})...\x1B[0m`);
       process.kill(pid, "SIGTERM");
@@ -53251,7 +53311,7 @@ function killExistingEdge(lp2) {
 }
 function acquireLock(lp2, kill = false) {
   try {
-    const pid = parseInt(fs13.readFileSync(lp2, "utf-8").trim(), 10);
+    const pid = parseInt(fs14.readFileSync(lp2, "utf-8").trim(), 10);
     if (!isNaN(pid) && isEdgeProcess(pid)) {
       if (kill) {
         killExistingEdge(lp2);
@@ -53259,13 +53319,13 @@ function acquireLock(lp2, kill = false) {
         return false;
     }
   } catch {}
-  fs13.writeFileSync(lp2, String(process.pid));
+  fs14.writeFileSync(lp2, String(process.pid));
   return true;
 }
 function releaseLock(lp2) {
   try {
-    if (fs13.readFileSync(lp2, "utf-8").trim() === String(process.pid))
-      fs13.unlinkSync(lp2);
+    if (fs14.readFileSync(lp2, "utf-8").trim() === String(process.pid))
+      fs14.unlinkSync(lp2);
   } catch {}
 }
 var MIN_BUN_VERSION = "1.3.14";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@todoforai/edge",
-  "version": "0.13.13",
+  "version": "0.13.14",
   "type": "module",
   "bin": {
     "todoforai-edge": "dist/index.js"