@danainnovations/cortex-mcp 1.0.69 → 1.0.71

package/dist/cli.js

@@ -1005,7 +1005,7 @@ function getWizardHtml() {
     }
 
     // \u2500\u2500 Step 3: Select MCPs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-    var REQUIRED_MCPS = ['github', 'supabase', 'vercel', 'bestbuy'];
+    var REQUIRED_MCPS = ['github', 'supabase', 'vercel', 'databricks', 'bestbuy'];
 
     var MCP_TOOLTIPS = {
       asana: 'Manage projects, tasks, and team workflows',
@@ -1019,6 +1019,7 @@ function getWizardHtml() {
       slack: 'Send messages, search conversations, and manage channels',
       powerbi: 'Build dashboards and run data queries on your reports',
       bestbuy: 'Search products, compare prices, and find store locations',
+      databricks: 'Query data warehouses, explore Unity Catalog, and manage jobs',
     };
 
     async function renderMcps() {
@@ -1851,17 +1852,17 @@ function getState() {
   return wizardState;
 }
 function parseBody(req) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
     req.on("end", () => {
       try {
-        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+        resolve2(JSON.parse(Buffer.concat(chunks).toString()));
       } catch {
-        resolve({});
+        resolve2({});
       }
     });
-    req.on("error", () => resolve({}));
+    req.on("error", () => resolve2({}));
   });
 }
 function json(res, data, status = 200) {
@@ -1904,8 +1905,8 @@ async function handleApiRoute(path, searchParams, req, res, options, onComplete)
       }
       const data = await resp.json();
       json(res, data);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
       json(res, { error: `Could not reach Cortex server: ${msg}` }, 502);
     }
     return true;
@@ -1953,8 +1954,8 @@ async function handleApiRoute(path, searchParams, req, res, options, onComplete)
           mcps
         );
         results.push({ client: clientType, success: true, message: msg });
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
         results.push({ client: clientType, success: false, error: msg });
       }
     }
@@ -2003,14 +2004,14 @@ async function handleApiRoute(path, searchParams, req, res, options, onComplete)
           json(res, { error: "Session expired. Please re-login." }, 401);
           return true;
         }
-        const err = await resp.json().catch(() => ({}));
-        json(res, { error: err.detail || `HTTP ${resp.status}` }, resp.status);
+        const err2 = await resp.json().catch(() => ({}));
+        json(res, { error: err2.detail || `HTTP ${resp.status}` }, resp.status);
         return true;
       }
       const data = await resp.json();
       json(res, data);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
       json(res, { error: `Could not reach Cortex server: ${msg}` }, 502);
     }
     return true;
@@ -2038,6 +2039,17 @@ async function handleApiRoute(path, searchParams, req, res, options, onComplete)
     const body = await parseBody(req);
     const mcps = body.mcps || [...DEFAULT_MCPS];
     const configuredClients = body.configuredClients || [];
+    const apiKey = getState().apiKey;
+    try {
+      await fetch(`${options.serverUrl}/api/v1/setup/complete`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey
+        }
+      });
+    } catch {
+    }
     const config = createConfig(getState().apiKey, mcps);
     config.configuredClients = configuredClients;
     writeConfig(config);
@@ -2050,7 +2062,7 @@ async function handleApiRoute(path, searchParams, req, res, options, onComplete)
 
 // src/wizard/server.ts
 function startWizardServer(options) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let completionResolve;
     const completionPromise = new Promise((r) => {
       completionResolve = r;
@@ -2075,8 +2087,8 @@ function startWizardServer(options) {
             res.writeHead(404, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ error: "Not found" }));
           }
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
+        } catch (err2) {
+          const msg = err2 instanceof Error ? err2.message : String(err2);
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: msg }));
         }
@@ -2087,7 +2099,7 @@ function startWizardServer(options) {
     });
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
-      resolve({
+      resolve2({
         port: addr.port,
         close: () => new Promise((r) => {
           server.close(() => r());
@@ -2172,8 +2184,8 @@ async function runConfigure(options) {
       selectedMcps
     );
     console.log(result);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
     console.error(`Failed to configure ${client}: ${msg}`);
     process.exit(1);
   }
@@ -2184,7 +2196,7 @@ async function runConfigure(options) {
 }
 
 // src/proxy/stdio-server.ts
-import { readFileSync as readFileSync4, statSync } from "fs";
+import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -2296,6 +2308,633 @@ var CortexHttpClient = class {
   }
 };
 
+// src/proxy/local-filesystem.ts
+import {
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  readdirSync,
+  rmSync,
+  statSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync4,
+  appendFileSync,
+  renameSync
+} from "fs";
+import { basename, dirname as dirname2, extname, join as join4, relative, resolve } from "path";
+var FILESYSTEM_TOOLS = /* @__PURE__ */ new Set([
+  "read_file",
+  "read_file_lines",
+  "write_file",
+  "append_file",
+  "create_directory",
+  "delete",
+  "move",
+  "copy",
+  "list_directory",
+  "exists",
+  "get_file_info",
+  "search_files",
+  "find_in_files",
+  "get_tree"
+]);
+var MAX_READ_SIZE = 50 * 1024 * 1024;
+var BINARY_CHECK_SIZE = 8192;
+var BINARY_SIGNATURES = [
+  Buffer.from([137, 80, 78, 71]),
+  // PNG
+  Buffer.from([255, 216, 255]),
+  // JPEG
+  Buffer.from("GIF8"),
+  // GIF
+  Buffer.from([80, 75, 3, 4]),
+  // ZIP / DOCX / XLSX
+  Buffer.from("%PDF"),
+  // PDF
+  Buffer.from([127, 69, 76, 70]),
+  // ELF
+  Buffer.from([254, 237, 250]),
+  // Mach-O
+  Buffer.from([207, 250, 237, 254]),
+  // Mach-O (reversed)
+  Buffer.from("MZ")
+  // Windows executable
+];
+function resolvePath(p) {
+  return resolve(p);
+}
+function isBinaryFile(filePath) {
+  try {
+    const fd = readFileSync4(filePath, { flag: "r" });
+    const chunk = fd.subarray(0, BINARY_CHECK_SIZE);
+    if (chunk.length === 0) return false;
+    for (const sig of BINARY_SIGNATURES) {
+      if (chunk.length >= sig.length && chunk.subarray(0, sig.length).equals(sig)) {
+        return true;
+      }
+    }
+    return chunk.includes(0);
+  } catch {
+    return false;
+  }
+}
+function globToRegex(pattern) {
+  let re = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*") {
+      re += ".*";
+    } else if (c === "?") {
+      re += ".";
+    } else if (c === "[") {
+      const close = pattern.indexOf("]", i + 1);
+      if (close !== -1) {
+        re += "[" + pattern.slice(i + 1, close) + "]";
+        i = close;
+      } else {
+        re += "\\[";
+      }
+    } else if (".+^${}()|\\".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  re += "$";
+  return new RegExp(re);
+}
+function fileType(isDir, isSymlink) {
+  if (isSymlink) return "symlink";
+  if (isDir) return "directory";
+  return "file";
+}
+function countDirectoryContents(dirPath) {
+  let files = 0;
+  let bytes = 0;
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join4(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        const sub = countDirectoryContents(full);
+        files += sub.files;
+        bytes += sub.bytes;
+      } else {
+        files += 1;
+        try {
+          bytes += statSync(full).size;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return { files, bytes };
+}
+function ok(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data) }],
+    isError: false
+  };
+}
+function err(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ success: false, error: message }) }],
+    isError: true
+  };
+}
+function handleReadFile(args) {
+  const filePath = resolvePath(args.path);
+  const encoding = args.encoding || "utf-8";
+  const stat = statSync(filePath);
+  if (!stat.isFile()) throw new Error("Not a file.");
+  if (stat.size > MAX_READ_SIZE) {
+    throw new Error(`File size (${stat.size} bytes) exceeds maximum allowed size (${MAX_READ_SIZE} bytes).`);
+  }
+  if (isBinaryFile(filePath)) {
+    const raw = readFileSync4(filePath);
+    return ok({
+      content: raw.toString("base64"),
+      is_binary: true,
+      size: stat.size,
+      encoding: "base64",
+      path: filePath
+    });
+  }
+  const text = readFileSync4(filePath, encoding);
+  return ok({
+    content: text,
+    is_binary: false,
+    size: stat.size,
+    encoding,
+    path: filePath
+  });
+}
+function handleReadFileLines(args) {
+  const filePath = resolvePath(args.path);
+  const encoding = args.encoding || "utf-8";
+  const startLine = args.start_line || 1;
+  const endLine = args.end_line;
+  const stat = statSync(filePath);
+  if (!stat.isFile()) throw new Error("Not a file.");
+  if (stat.size > MAX_READ_SIZE) {
+    throw new Error(`File size (${stat.size} bytes) exceeds maximum allowed size.`);
+  }
+  if (startLine < 1) throw new Error("start_line must be >= 1.");
+  if (endLine !== void 0 && endLine < startLine) throw new Error("end_line must be >= start_line.");
+  const text = readFileSync4(filePath, encoding);
+  const allLines = text.split(/\n/);
+  const totalLines = allLines.length;
+  const startIdx = startLine - 1;
+  const endIdx = endLine !== void 0 ? endLine : totalLines;
+  const selected = allLines.slice(startIdx, endIdx);
+  const actualEnd = Math.min(endIdx, totalLines);
+  return ok({
+    content: selected.join("\n"),
+    start_line: startLine,
+    end_line: actualEnd,
+    total_lines: totalLines,
+    size: stat.size,
+    path: filePath
+  });
+}
+function handleWriteFile(args) {
+  const filePath = resolvePath(args.path);
+  const content = args.content;
+  const encoding = args.encoding || "utf-8";
+  const isBinary = args.is_binary || false;
+  const overwrite = args.overwrite !== false;
+  const createParents = args.create_parents || false;
+  const created = !existsSync4(filePath);
+  if (!overwrite && !created) {
+    throw new Error("File already exists.");
+  }
+  if (createParents) {
+    mkdirSync4(dirname2(filePath), { recursive: true });
+  }
+  let bytesWritten;
+  let usedEncoding;
+  if (isBinary) {
+    const raw = Buffer.from(content, "base64");
+    writeFileSync4(filePath, raw);
+    bytesWritten = raw.length;
+    usedEncoding = "base64";
+  } else {
+    const encoded = Buffer.from(content, encoding);
+    writeFileSync4(filePath, content, encoding);
+    bytesWritten = encoded.length;
+    usedEncoding = encoding;
+  }
+  return ok({
+    path: filePath,
+    bytes_written: bytesWritten,
+    created,
+    encoding: usedEncoding
+  });
+}
+function handleAppendFile(args) {
+  const filePath = resolvePath(args.path);
+  const content = args.content;
+  const encoding = args.encoding || "utf-8";
+  if (!existsSync4(filePath)) throw new Error("File not found.");
+  const encoded = Buffer.from(content, encoding);
+  appendFileSync(filePath, content, encoding);
+  const newSize = statSync(filePath).size;
+  return ok({
+    path: filePath,
+    bytes_written: encoded.length,
+    new_size: newSize
+  });
+}
+function handleCreateDirectory(args) {
+  const dirPath = resolvePath(args.path);
+  const parents = args.parents !== false;
+  if (existsSync4(dirPath)) {
+    return ok({ path: dirPath, created: false });
+  }
+  if (parents) {
+    mkdirSync4(dirPath, { recursive: true });
+  } else {
+    mkdirSync4(dirPath);
+  }
+  return ok({ path: dirPath, created: true });
+}
+function handleDelete(args) {
+  const targetPath = resolvePath(args.path);
+  const recursive = args.recursive || false;
+  if (!existsSync4(targetPath)) throw new Error("Path not found.");
+  const stat = statSync(targetPath, { throwIfNoEntry: false });
+  if (!stat) throw new Error("Path not found.");
+  if (stat.isDirectory()) {
+    const { files: filesDeleted, bytes: bytesFreed } = countDirectoryContents(targetPath);
+    if (recursive) {
+      rmSync(targetPath, { recursive: true });
+    } else {
+      rmSync(targetPath);
+    }
+    return ok({
+      path: targetPath,
+      type: "directory",
+      files_deleted: recursive ? filesDeleted : 0,
+      bytes_freed: recursive ? bytesFreed : 0
+    });
+  }
+  const size = stat.size;
+  unlinkSync2(targetPath);
+  return ok({
+    path: targetPath,
+    type: "file",
+    files_deleted: 1,
+    bytes_freed: size
+  });
+}
+function handleMove(args) {
+  const source = resolvePath(args.source);
+  const destination = resolvePath(args.destination);
+  const overwrite = args.overwrite || false;
+  if (!existsSync4(source)) throw new Error("Source path not found.");
+  if (existsSync4(destination) && !overwrite) throw new Error("Destination already exists.");
+  const stat = statSync(source);
+  const type = stat.isDirectory() ? "directory" : "file";
+  const bytesMoved = stat.isDirectory() ? countDirectoryContents(source).bytes : stat.size;
+  try {
+    renameSync(source, destination);
+  } catch (e) {
+    if (e.code === "EXDEV") {
+      if (stat.isDirectory()) {
+        cpSync(source, destination, { recursive: true });
+        rmSync(source, { recursive: true });
+      } else {
+        copyFileSync(source, destination);
+        unlinkSync2(source);
+      }
+    } else {
+      throw e;
+    }
+  }
+  return ok({
+    source,
+    destination,
+    type,
+    bytes_moved: bytesMoved
+  });
+}
+function handleCopy(args) {
+  const source = resolvePath(args.source);
+  const destination = resolvePath(args.destination);
+  const overwrite = args.overwrite || false;
+  if (!existsSync4(source)) throw new Error("Source path not found.");
+  if (existsSync4(destination) && !overwrite) throw new Error("Destination already exists.");
+  const stat = statSync(source);
+  if (stat.isDirectory()) {
+    if (existsSync4(destination) && overwrite) {
+      rmSync(destination, { recursive: true });
+    }
+    cpSync(source, destination, { recursive: true });
+    const { bytes } = countDirectoryContents(destination);
+    return ok({ source, destination, type: "directory", bytes_copied: bytes });
+  }
+  copyFileSync(source, destination);
+  const bytesCopied = statSync(destination).size;
+  return ok({ source, destination, type: "file", bytes_copied: bytesCopied });
+}
+function handleListDirectory(args) {
+  const dirPath = resolvePath(args.path);
+  const recursive = args.recursive || false;
+  const maxDepth = args.max_depth || 1;
+  const pattern = args.pattern;
+  const includeHidden = args.include_hidden || false;
+  if (!existsSync4(dirPath)) throw new Error("Directory not found.");
+  const stat = statSync(dirPath);
+  if (!stat.isDirectory()) throw new Error("Path is not a directory.");
+  const effectiveDepth = recursive ? maxDepth : 1;
+  const patternRe = pattern ? globToRegex(pattern) : null;
+  const entries = [];
+  function scan(dir, depth) {
+    if (depth >= effectiveDepth) return;
+    let dirents;
+    try {
+      dirents = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    dirents.sort((a, b) => a.name.localeCompare(b.name));
+    for (const d of dirents) {
+      if (!includeHidden && d.name.startsWith(".")) continue;
+      const fullPath = join4(dir, d.name);
+      const isDir = d.isDirectory();
+      if (patternRe && !patternRe.test(d.name)) {
+        if (isDir && effectiveDepth > 1) {
+          scan(fullPath, depth + 1);
+        }
+        continue;
+      }
+      let size = 0;
+      let mtime = (/* @__PURE__ */ new Date()).toISOString();
+      try {
+        const s = statSync(fullPath);
+        size = isDir ? 0 : s.size;
+        mtime = new Date(s.mtimeMs).toISOString();
+      } catch {
+      }
+      entries.push({
+        name: d.name,
+        path: relative(dirPath, fullPath),
+        type: fileType(isDir, d.isSymbolicLink()),
+        size,
+        modified_at: mtime,
+        is_hidden: d.name.startsWith(".")
+      });
+      if (isDir && effectiveDepth > 1) {
+        scan(fullPath, depth + 1);
+      }
+    }
+  }
+  scan(dirPath, 0);
+  return ok({
+    path: dirPath,
+    entries,
+    total_count: entries.length
+  });
+}
+function handleExists(args) {
+  const targetPath = resolvePath(args.path);
+  const pathExists = existsSync4(targetPath);
+  let type = null;
+  if (pathExists) {
+    const stat = statSync(targetPath, { throwIfNoEntry: false });
+    if (stat) {
+      type = fileType(stat.isDirectory(), stat.isSymbolicLink());
+    }
+  }
+  return ok({ exists: pathExists, path: targetPath, type });
+}
+function handleGetFileInfo(args) {
+  const filePath = resolvePath(args.path);
+  if (!existsSync4(filePath)) throw new Error("Path not found.");
+  const stat = statSync(filePath, { throwIfNoEntry: false });
+  if (!stat) throw new Error("Path not found.");
+  const isDir = stat.isDirectory();
+  const isSymlink = stat.isSymbolicLink();
+  const name = basename(filePath);
+  const ext = isDir ? null : extname(name) || null;
+  const binary = !isDir && !isSymlink ? isBinaryFile(filePath) : false;
+  return ok({
+    name,
+    path: filePath,
+    type: fileType(isDir, isSymlink),
+    size: isDir ? 0 : stat.size,
+    modified_at: new Date(stat.mtimeMs).toISOString(),
+    created_at: stat.birthtimeMs ? new Date(stat.birthtimeMs).toISOString() : null,
+    extension: ext,
+    is_hidden: name.startsWith("."),
+    is_binary: binary
+  });
+}
+function handleSearchFiles(args) {
+  const searchPath = resolvePath(args.path);
+  const pattern = args.pattern || "*";
+  const recursive = args.recursive !== false;
+  const includeHidden = args.include_hidden || false;
+  const maxResults = args.max_results || 1e3;
+  if (!existsSync4(searchPath)) throw new Error("Directory not found.");
+  if (!statSync(searchPath).isDirectory()) throw new Error("Path is not a directory.");
+  const patternRe = globToRegex(pattern);
+  const matches = [];
+  let totalMatches = 0;
+  function scan(dir) {
+    let dirents;
+    try {
+      dirents = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const d of dirents) {
+      if (!includeHidden) {
+        if (d.name.startsWith(".")) continue;
+      }
+      const fullPath = join4(dir, d.name);
+      if (d.isDirectory()) {
+        if (recursive) scan(fullPath);
+        continue;
+      }
+      if (patternRe.test(d.name)) {
+        totalMatches++;
+        if (matches.length < maxResults) {
+          matches.push(relative(searchPath, fullPath));
+        }
+      }
+    }
+  }
+  scan(searchPath);
+  return ok({
+    matches,
+    total_matches: totalMatches,
+    truncated: totalMatches > maxResults,
+    search_path: searchPath,
+    pattern
+  });
+}
+function handleFindInFiles(args) {
+  const searchPath = resolvePath(args.path);
+  const query = args.query;
+  const isRegex = args.is_regex || false;
+  const caseSensitive = args.case_sensitive !== false;
+  const filePattern = args.pattern;
+  const contextLines = args.context_lines || 0;
+  const maxResults = args.max_results || 500;
+  const includeHidden = args.include_hidden || false;
+  if (!existsSync4(searchPath)) throw new Error("Directory not found.");
+  if (!statSync(searchPath).isDirectory()) throw new Error("Path is not a directory.");
+  const flags = caseSensitive ? "" : "i";
+  const re = isRegex ? new RegExp(query, flags) : new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
+  const patternRe = filePattern ? globToRegex(filePattern) : null;
+  const results = [];
+  let totalMatches = 0;
+  let filesSearched = 0;
+  let filesWithMatches = 0;
+  function scan(dir) {
+    let dirents;
+    try {
+      dirents = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const d of dirents) {
+      if (!includeHidden && d.name.startsWith(".")) continue;
+      const fullPath = join4(dir, d.name);
+      if (d.isDirectory()) {
+        scan(fullPath);
+        continue;
+      }
+      if (patternRe && !patternRe.test(d.name)) continue;
+      if (isBinaryFile(fullPath)) continue;
+      filesSearched++;
+      let fileHasMatch = false;
+      let lines;
+      try {
+        const text = readFileSync4(fullPath, "utf-8");
+        lines = text.split("\n");
+      } catch {
+        continue;
+      }
+      for (let i = 0; i < lines.length; i++) {
+        if (re.test(lines[i])) {
+          totalMatches++;
+          fileHasMatch = true;
+          if (results.length < maxResults) {
+            const ctxStart = Math.max(0, i - contextLines);
+            const ctxEnd = Math.min(lines.length, i + contextLines + 1);
+            results.push({
+              file: relative(searchPath, fullPath),
+              line: i + 1,
+              content: lines[i],
+              context_before: lines.slice(ctxStart, i),
+              context_after: lines.slice(i + 1, ctxEnd)
+            });
+          }
+        }
+      }
+      if (fileHasMatch) filesWithMatches++;
+    }
+  }
+  scan(searchPath);
+  return ok({
+    results,
+    total_matches: totalMatches,
+    files_searched: filesSearched,
+    files_with_matches: filesWithMatches,
+    truncated: totalMatches > maxResults,
+    query
+  });
+}
+function handleGetTree(args) {
+  const rootPath = resolvePath(args.path);
+  const maxDepth = args.max_depth || 3;
+  const includeHidden = args.include_hidden || false;
+  const maxEntries = args.max_entries || 500;
+  if (!existsSync4(rootPath)) throw new Error("Directory not found.");
+  if (!statSync(rootPath).isDirectory()) throw new Error("Path is not a directory.");
+  const lines = [];
+  let entryCount = 0;
+  let truncated = false;
+  const rootName = basename(rootPath) || rootPath;
+  lines.push(rootName + "/");
+  function buildTree(dirPath, prefix, depth) {
+    if (truncated || depth >= maxDepth) return;
+    let dirents;
+    try {
+      dirents = readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (!includeHidden) {
+      dirents = dirents.filter((d) => !d.name.startsWith("."));
+    }
+    dirents.sort((a, b) => a.name.localeCompare(b.name));
+    for (let i = 0; i < dirents.length; i++) {
+      if (truncated) return;
+      entryCount++;
+      if (entryCount > maxEntries) {
+        truncated = true;
+        lines.push(prefix + "... (truncated)");
+        return;
+      }
+      const d = dirents[i];
+      const isLast = i === dirents.length - 1;
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+      const fullPath = join4(dirPath, d.name);
+      if (d.isDirectory()) {
+        lines.push(prefix + connector + d.name + "/");
+        buildTree(fullPath, childPrefix, depth + 1);
+      } else {
+        lines.push(prefix + connector + d.name);
+      }
+    }
+  }
+  buildTree(rootPath, "", 0);
+  return ok({
+    tree: lines.join("\n"),
+    path: rootPath,
+    entry_count: entryCount,
+    truncated,
+    max_depth: maxDepth
+  });
+}
+var HANDLERS = {
+  read_file: handleReadFile,
+  read_file_lines: handleReadFileLines,
+  write_file: handleWriteFile,
+  append_file: handleAppendFile,
+  create_directory: handleCreateDirectory,
+  delete: handleDelete,
+  move: handleMove,
+  copy: handleCopy,
+  list_directory: handleListDirectory,
+  exists: handleExists,
+  get_file_info: handleGetFileInfo,
+  search_files: handleSearchFiles,
+  find_in_files: handleFindInFiles,
+  get_tree: handleGetTree
+};
+function handleLocalFilesystemTool(_toolName, baseName, args) {
+  console.error(`[cortex-mcp] filesystem.${baseName}: executing locally`);
+  const handler = HANDLERS[baseName];
+  if (!handler) {
+    return err(`Unknown filesystem tool: ${baseName}`);
+  }
+  try {
+    return handler(args);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(`[cortex-mcp] filesystem.${baseName} error: ${message}`);
+    return err(message);
+  }
+}
+
 // src/proxy/stdio-server.ts
 var UPLOAD_TOOLS = /* @__PURE__ */ new Set(["upload_file", "upload_file_to_sharepoint"]);
 var INLINE_UPLOAD_MAX = 3 * 1024 * 1024;
@@ -2360,7 +2999,7 @@ async function handleLocalFileUpload(cortex, toolName, args) {
   const filePath = args.file_path;
   let fileSize;
   try {
-    fileSize = statSync(filePath).size;
+    fileSize = statSync2(filePath).size;
   } catch {
     return {
       content: [{ type: "text", text: JSON.stringify({
@@ -2371,7 +3010,7 @@ async function handleLocalFileUpload(cortex, toolName, args) {
     };
   }
   if (fileSize <= INLINE_UPLOAD_MAX) {
-    const fileBuffer2 = readFileSync4(filePath);
+    const fileBuffer2 = readFileSync5(filePath);
     const base64Content = fileBuffer2.toString("base64");
     const forwardArgs = { ...args, content: base64Content };
     delete forwardArgs.file_path;
@@ -2423,7 +3062,7 @@ async function handleLocalFileUpload(cortex, toolName, args) {
       isError: true
     };
   }
-  const fileBuffer = readFileSync4(filePath);
+  const fileBuffer = readFileSync5(filePath);
   const chunkSize = 2.5 * 1024 * 1024;
   const total = fileBuffer.length;
   let driveItem = {};
@@ -2493,8 +3132,8 @@ async function startStdioServer(options) {
       console.error("[cortex-mcp] Initializing backend session...");
       await cortex.initialize();
       console.error("[cortex-mcp] Backend session established.");
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
       console.error(`[cortex-mcp] Backend initialization failed: ${msg}`);
     }
     initialized = true;
@@ -2517,6 +3156,9 @@ async function startStdioServer(options) {
     if (UPLOAD_TOOLS.has(baseName) && typedArgs.file_path) {
       return handleLocalFileUpload(cortex, name, typedArgs);
     }
+    if (FILESYSTEM_TOOLS.has(baseName)) {
+      return handleLocalFilesystemTool(name, baseName, typedArgs);
+    }
     const response = await cortex.callTool(name, typedArgs);
     if (response.error) {
       return {
@@ -2587,7 +3229,7 @@ function runStatus() {
 }
 
 // src/cli/reset.ts
-import { existsSync as existsSync4, unlinkSync as unlinkSync2, rmdirSync } from "fs";
+import { existsSync as existsSync5, unlinkSync as unlinkSync3, rmdirSync } from "fs";
 function runReset() {
   console.log("");
   console.log("  Resetting Cortex MCP configuration...");
@@ -2608,8 +3250,8 @@ function runReset() {
     `  Codex:          ${codexReset ? "entries removed" : "no entries found"}`
   );
   const configPath = getConfigPath();
-  if (existsSync4(configPath)) {
-    unlinkSync2(configPath);
+  if (existsSync5(configPath)) {
+    unlinkSync3(configPath);
     console.log(`  Config file:    removed`);
   }
   const configDir = getConfigDir();
@@ -2631,15 +3273,15 @@ function log2(msg) {
   process.stderr.write(msg + "\n");
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function waitForEnter() {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     process.stdin.setRawMode?.(false);
     process.stdin.resume();
     process.stdin.once("data", () => {
       process.stdin.pause();
-      resolve();
+      resolve2();
     });
   });
 }
@@ -2663,16 +3305,16 @@ async function connectProvider(providerName, displayName, apiKey, serverUrl, ins
         log2("  Error: Your session has expired. Run 'cortex-mcp login' to re-authenticate.");
         return false;
       }
-      const err = await resp.json().catch(() => ({}));
-      log2(`  Error: ${err.detail || `HTTP ${resp.status}`}`);
+      const err2 = await resp.json().catch(() => ({}));
+      log2(`  Error: ${err2.detail || `HTTP ${resp.status}`}`);
       return false;
     }
     const data = await resp.json();
     sessionId = data.session_id;
     authUrl = data.authorization_url;
     expiresIn = data.expires_in;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
     log2(`  Error: Could not reach Cortex server at ${serverUrl}`);
     log2(`  ${msg}`);
     return false;
@@ -2777,7 +3419,7 @@ function log3(msg) {
   process.stderr.write(msg + "\n");
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function loginWithSSO(serverUrl, emailHint) {
   let sessionId;
@@ -2801,8 +3443,8 @@ async function loginWithSSO(serverUrl, emailHint) {
     sessionId = data.session_id;
     authUrl = data.auth_url;
     expiresIn = data.expires_in;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
     log3(`  Error: Could not reach Cortex server at ${serverUrl}`);
     log3(`  ${msg}`);
     return { status: "failed" };
@@ -2906,8 +3548,8 @@ async function showConnectionsAndAutoConnect(apiKey, serverUrl) {
     input: process.stdin,
     output: process.stderr
   });
-  const ask = (question) => new Promise((resolve) => {
-    rl.question(question, (answer) => resolve(answer.trim().toLowerCase()));
+  const ask = (question) => new Promise((resolve2) => {
+    rl.question(question, (answer) => resolve2(answer.trim().toLowerCase()));
   });
   for (const mcp of personalMcps) {
     const answer = await ask(
@@ -2951,10 +3593,10 @@ async function promptForEmailHint(ssoEmail) {
     input: process.stdin,
     output: process.stderr
   });
-  const answer = await new Promise((resolve) => {
+  const answer = await new Promise((resolve2) => {
     rl.question(
       "  Enter your company email address: ",
-      (a) => resolve(a.trim())
+      (a) => resolve2(a.trim())
     );
   });
   rl.close();
@@ -3036,6 +3678,16 @@ async function runLogin(emailHint) {
     writeConfig(existingConfig);
   }
   await showConnectionsAndAutoConnect(apiKey, serverUrl);
+  try {
+    await fetch(`${serverUrl}/api/v1/setup/complete`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      }
+    });
+  } catch {
+  }
   log3("  Done! Restart your AI clients to apply.");
   log3("");
 }
@@ -3215,11 +3867,11 @@ program.name("cortex-mcp").description(
 program.command("setup").description("Interactive setup wizard \u2014 configure MCPs and AI clients").action(async () => {
   try {
     await runSetup();
-  } catch (err) {
-    if (err.code === "ERR_USE_AFTER_CLOSE") {
+  } catch (err2) {
+    if (err2.code === "ERR_USE_AFTER_CLOSE") {
       process.exit(0);
     }
-    console.error("Setup failed:", err);
+    console.error("Setup failed:", err2);
     process.exit(1);
   }
 });
@@ -3249,11 +3901,11 @@ program.command("login").description("Sign in with your company Okta SSO account
 ).action(async (options) => {
   try {
     await runLogin(options.email);
-  } catch (err) {
-    if (err.code === "ERR_USE_AFTER_CLOSE") {
+  } catch (err2) {
+    if (err2.code === "ERR_USE_AFTER_CLOSE") {
       process.exit(0);
     }
-    console.error("Login failed:", err);
+    console.error("Login failed:", err2);
     process.exit(1);
   }
 });
@@ -3266,27 +3918,27 @@ program.command("whoami").description("Show current authenticated user").action(
 program.command("connect <provider>").description("Connect your personal account to an MCP service (e.g., asana)").action(async (provider) => {
   try {
     await runConnect(provider);
-  } catch (err) {
-    if (err.code === "ERR_USE_AFTER_CLOSE") {
+  } catch (err2) {
+    if (err2.code === "ERR_USE_AFTER_CLOSE") {
       process.exit(0);
     }
-    console.error("Connect failed:", err);
+    console.error("Connect failed:", err2);
     process.exit(1);
   }
 });
 program.command("connections").description("List your OAuth connections to MCP services").action(async () => {
   try {
     await runConnections();
-  } catch (err) {
-    console.error("Failed:", err);
+  } catch (err2) {
+    console.error("Failed:", err2);
     process.exit(1);
   }
 });
 program.command("disconnect <provider>").description("Remove your personal OAuth connection to an MCP service").action(async (provider) => {
   try {
     await runDisconnect(provider);
-  } catch (err) {
-    console.error("Disconnect failed:", err);
+  } catch (err2) {
+    console.error("Disconnect failed:", err2);
     process.exit(1);
   }
 });