@ganglion/xacpx 0.17.0-beta.1 → 0.17.0-beta.3

package/dist/cli.js

@@ -25585,6 +25585,9 @@ function terminalIdleTimeoutSeconds(config4) {
   const v = config4.terminal?.idleTimeoutSeconds;
   return typeof v === "number" && v > 0 ? v : 900;
 }
+function filesWriteEnabled(config4) {
+  return config4.files?.writeEnabled === true;
+}
 
 // src/orchestration/orchestration-server.ts
 import { chmod as chmod4, rm as rm8 } from "node:fs/promises";
@@ -33681,11 +33684,11 @@ async function readNativeSessionHistory(opts) {
 var init_native_session_history = () => {};
 
 // src/control/workspace-fs.ts
-import { execFile } from "node:child_process";
+import { execFile, spawn as spawn11 } from "node:child_process";
 import { promisify } from "node:util";
 import { homedir as homedir12 } from "node:os";
-import { readdir as readdir4, realpath, stat as stat3, open as open5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, relative, resolve as resolve3, sep } from "node:path";
+import { readdir as readdir4, realpath, stat as stat3, open as open5, readFile as readFile15, writeFile as writeFile8, mkdir as mkdir9, rename as fsRename, cp, rm as rm10 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname12, isAbsolute as isAbsolute3, relative, resolve as resolve3, sep } from "node:path";
 function expandHome2(p) {
   if (p === "~")
     return homedir12();
@@ -33723,8 +33726,93 @@ class WorkspaceFs {
     const rel = abs === root ? "" : relative(root, abs).split(sep).join("/");
     return { root, abs, rel };
   }
-  async listDirectory(workspace3, relPath) {
+  async resolveParent(workspace3, relPath) {
+    if (relPath && isAbsolute3(relPath))
+      throw new Error("path-must-be-relative");
+    const trimmed = (relPath ?? "").replace(/\/+$/, "");
+    if (!trimmed)
+      throw new Error("bad-target");
+    const name = basename3(trimmed);
+    if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\\")) {
+      throw new Error("bad-target");
+    }
+    const parentRel = dirname12(trimmed);
+    const { root, abs: parentAbs, rel: parentRelNorm } = await this.resolve(workspace3, parentRel === "." ? undefined : parentRel);
+    const targetAbs = resolve3(parentAbs, name);
+    const rel = parentRelNorm ? `${parentRelNorm}/${name}` : name;
+    return { root, parentAbs, name, targetAbs, rel };
+  }
+  async createFile(workspace3, relPath) {
+    const { targetAbs, rel } = await this.resolveParent(workspace3, relPath);
+    try {
+      await writeFile8(targetAbs, "", { flag: "wx" });
+    } catch (e) {
+      if (e.code === "EEXIST")
+        throw new Error("already-exists");
+      throw e;
+    }
+    return { path: rel };
+  }
+  async createDir(workspace3, relPath) {
+    const { targetAbs, rel } = await this.resolveParent(workspace3, relPath);
+    try {
+      await mkdir9(targetAbs);
+    } catch (e) {
+      if (e.code === "EEXIST")
+        throw new Error("already-exists");
+      throw e;
+    }
+    return { path: rel };
+  }
+  async rename(workspace3, relPath, newName) {
+    const src = await this.resolve(workspace3, relPath);
+    if (!src.rel)
+      throw new Error("bad-target");
+    if (newName.includes("/") || newName.includes("\\"))
+      throw new Error("bad-target");
+    const destRelInput = src.rel.includes("/") ? `${src.rel.slice(0, src.rel.lastIndexOf("/"))}/${newName}` : newName;
+    const dest = await this.resolveParent(workspace3, destRelInput);
+    try {
+      await stat3(dest.targetAbs);
+      throw new Error("already-exists");
+    } catch (e) {
+      if (e.message === "already-exists")
+        throw e;
+    }
+    await fsRename(src.abs, dest.targetAbs);
+    return { path: dest.rel };
+  }
+  async duplicate(workspace3, relPath) {
+    const src = await this.resolve(workspace3, relPath);
+    if (!src.rel)
+      throw new Error("bad-target");
+    const parent = await this.resolveParent(workspace3, src.rel);
+    const siblings = new Set(await readdir4(parent.parentAbs));
+    const newBase = copyName(siblings, parent.name);
+    const destAbs = resolve3(parent.parentAbs, newBase);
+    await cp(src.abs, destAbs, { recursive: true });
+    const destRel = parent.rel.includes("/") ? `${parent.rel.slice(0, parent.rel.lastIndexOf("/"))}/${newBase}` : newBase;
+    return { path: destRel };
+  }
+  async remove(workspace3, relPath) {
+    const { abs, rel } = await this.resolve(workspace3, relPath);
+    if (!rel)
+      throw new Error("refuse-delete-root");
+    await rm10(abs, { recursive: true, force: false });
+    return { path: rel };
+  }
+  async readFileBytes(workspace3, relPath) {
     const { abs, rel } = await this.resolve(workspace3, relPath);
+    const info = await stat3(abs);
+    if (!info.isFile())
+      throw new Error("not-a-file");
+    if (info.size > DOWNLOAD_MAX)
+      throw new Error("file-too-large");
+    const buf = await readFile15(abs);
+    return { path: rel, base64: buf.toString("base64"), size: info.size, mimeType: mimeForName(basename3(abs)) };
+  }
+  async listDirectory(workspace3, relPath) {
+    const { root, abs, rel } = await this.resolve(workspace3, relPath);
     const dirents = await readdir4(abs, { withFileTypes: true });
     const entries = [];
     for (const d of dirents.slice(0, MAX_ENTRIES)) {
@@ -33741,7 +33829,49 @@ class WorkspaceFs {
       }
     }
     entries.sort((a, b) => a.type !== b.type ? a.type === "dir" ? -1 : 1 : a.name.localeCompare(b.name));
-    return { workspace: workspace3, path: rel, entries };
+    const relOf = (name, isDir) => (rel ? `${rel}/${name}` : name) + (isDir ? "/" : "");
+    const ignoredSet = await this.gitCheckIgnore(root, entries.map((e) => relOf(e.name, e.type === "dir")));
+    for (const e of entries) {
+      if (ignoredSet.has(relOf(e.name, e.type === "dir")))
+        e.ignored = true;
+    }
+    return { workspace: workspace3, path: rel, entries, root, sep };
+  }
+  gitCheckIgnore(root, relPaths) {
+    return new Promise((resolvePromise) => {
+      if (!relPaths.length)
+        return resolvePromise(new Set);
+      const ignored = new Set;
+      let out = "";
+      let child;
+      try {
+        child = spawn11("git", ["-C", root, "check-ignore", "-z", "--stdin"], { stdio: ["pipe", "pipe", "ignore"] });
+      } catch {
+        return resolvePromise(ignored);
+      }
+      const killer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {}
+      }, GIT_TIMEOUT_MS);
+      child.on("error", () => {
+        clearTimeout(killer);
+        resolvePromise(ignored);
+      });
+      child.stdout.on("data", (b) => {
+        out += b.toString();
+      });
+      child.on("close", () => {
+        clearTimeout(killer);
+        for (const p of out.split("\x00")) {
+          if (p)
+            ignored.add(p);
+        }
+        resolvePromise(ignored);
+      });
+      child.stdin.on("error", () => {});
+      child.stdin.end(relPaths.join("\x00") + "\x00");
+    });
   }
   async readFile(workspace3, relPath) {
     const { abs, rel } = await this.resolve(workspace3, relPath);
@@ -33759,6 +33889,7 @@ class WorkspaceFs {
         path: rel,
         content: binary ? "" : slice.toString("utf8"),
         size: info.size,
+        mtimeMs: info.mtimeMs,
         truncated: info.size > FILE_READ_CAP,
         binary
       };
@@ -33766,16 +33897,45 @@ class WorkspaceFs {
       await fh.close();
     }
   }
-  async search(workspace3, query) {
-    const { root } = await this.resolve(workspace3, undefined);
-    const needle = query.trim().toLowerCase();
+  async writeFile(workspace3, relPath, content, expected) {
+    const { abs, rel } = await this.resolve(workspace3, relPath);
+    const info = await stat3(abs);
+    if (!info.isFile())
+      throw new Error("not-a-file");
+    if (info.size > FILE_READ_CAP)
+      throw new Error("file-too-large");
+    if (content.includes("\x00"))
+      throw new Error("is-binary");
+    if (Buffer.byteLength(content, "utf8") > FILE_READ_CAP)
+      throw new Error("file-too-large");
+    if (info.mtimeMs !== expected.mtimeMs || info.size !== expected.size)
+      throw new Error("stale-write");
+    await import_write_file_atomic3.default(abs, content);
+    const after = await stat3(abs);
+    return { path: rel, mtimeMs: after.mtimeMs, size: after.size };
+  }
+  async search(workspace3, opts) {
+    const { root, abs: base, rel: scopeRel } = await this.resolve(workspace3, opts.path);
+    const query = opts.query.trim();
+    const empty = { workspace: workspace3, query, matches: [], hits: [], truncated: false };
+    if (!query)
+      return empty;
+    if ((opts.mode ?? "name") === "content") {
+      return this.contentGrep(workspace3, root, base, scopeRel, opts, query);
+    }
+    const matcher = buildMatcher(query, opts);
+    const inc = opts.include ? globToRegExp(opts.include) : null;
+    const exc = opts.exclude ? globToRegExp(opts.exclude) : null;
     const matches = [];
-    if (!needle)
-      return { workspace: workspace3, query, matches, truncated: false };
     let scanned = 0;
     let truncated = false;
-    const queue = [root];
+    const deadline = Date.now() + SEARCH_DEADLINE_MS;
+    const queue = [base];
     while (queue.length) {
+      if (Date.now() > deadline) {
+        truncated = true;
+        break;
+      }
       const dir = queue.shift();
       let dirents;
       try {
@@ -33784,6 +33944,10 @@ class WorkspaceFs {
         continue;
       }
       for (const d of dirents) {
+        if (Date.now() > deadline) {
+          truncated = true;
+          break;
+        }
         if (++scanned > SEARCH_MAX_SCAN) {
           truncated = true;
           break;
@@ -33795,7 +33959,11 @@ class WorkspaceFs {
             queue.push(resolve3(dir, d.name));
         } else if (d.isFile()) {
           const rel = relative(root, resolve3(dir, d.name)).split(sep).join("/");
-          if (rel.toLowerCase().includes(needle)) {
+          if (inc && !inc.test(rel))
+            continue;
+          if (exc && exc.test(rel))
+            continue;
+          if (matcher(rel)) {
             matches.push(rel);
             if (matches.length >= SEARCH_MAX_RESULTS) {
               truncated = true;
@@ -33808,18 +33976,199 @@ class WorkspaceFs {
         break;
     }
     matches.sort();
-    return { workspace: workspace3, query, matches, truncated };
+    return { workspace: workspace3, query, matches, hits: [], truncated };
+  }
+  async contentGrep(workspace3, root, base, scopeRel, opts, query) {
+    const inc = opts.include ? globToRegExp(opts.include) : null;
+    const exc = opts.exclude ? globToRegExp(opts.exclude) : null;
+    const inGit = await execFileAsync("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" }).then(() => true).catch(() => false);
+    if (inGit) {
+      const args = ["-C", root, "grep", "-n", "--column", "-I", "--no-color", "--untracked"];
+      if (!opts.matchCase)
+        args.push("-i");
+      if (opts.wholeWord)
+        args.push("-w");
+      args.push(opts.regex ? "-E" : "-F");
+      args.push("-e", query, "--", scopeRel || ".");
+      let stdout2 = "";
+      let killed = false;
+      try {
+        stdout2 = (await execFileAsync("git", args, { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
+      } catch (e) {
+        killed = e.killed === true || e.signal === "SIGKILL";
+        const code = e.code;
+        if (code === 1)
+          stdout2 = "";
+        else {
+          const out = e.stdout;
+          stdout2 = typeof out === "string" ? out : "";
+        }
+      }
+      const hits2 = [];
+      let truncated2 = killed;
+      for (const raw of stdout2.split(`
+`)) {
+        if (!raw)
+          continue;
+        const m = raw.match(/^(.*?):(\d+):(\d+):(.*)$/);
+        if (!m)
+          continue;
+        const p = m[1].split(sep).join("/");
+        if (inc && !inc.test(p))
+          continue;
+        if (exc && exc.test(p))
+          continue;
+        hits2.push({ path: p, line: Number(m[2]), text: m[4].slice(0, 400) });
+        if (hits2.length >= SEARCH_CONTENT_MAX_HITS) {
+          truncated2 = true;
+          break;
+        }
+      }
+      return { workspace: workspace3, query, matches: [], hits: hits2, truncated: truncated2 };
+    }
+    try {
+      const args = ["grep", "--no-index", "-n", "--column", "-I", "--no-color"];
+      if (!opts.matchCase)
+        args.push("-i");
+      if (opts.wholeWord)
+        args.push("-w");
+      args.push(opts.regex ? "-E" : "-F");
+      args.push("-e", query, "--", ".", ":(exclude)node_modules/", ":(exclude).git/");
+      let stdout2 = "";
+      let killed = false;
+      try {
+        stdout2 = (await execFileAsync("git", args, { cwd: base, maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
+      } catch (e) {
+        if (e.code === "ENOENT")
+          throw e;
+        killed = e.killed === true || e.signal === "SIGKILL";
+        const code = e.code;
+        if (code === 1)
+          stdout2 = "";
+        else {
+          const out = e.stdout;
+          stdout2 = typeof out === "string" ? out : "";
+        }
+      }
+      const hits2 = [];
+      let truncated2 = killed;
+      for (const raw of stdout2.split(`
+`)) {
+        if (!raw)
+          continue;
+        const m = raw.match(/^(.*?):(\d+):(\d+):(.*)$/);
+        if (!m)
+          continue;
+        const relToBase = m[1].split(sep).join("/");
+        const p = scopeRel ? `${scopeRel}/${relToBase}` : relToBase;
+        if (inc && !inc.test(p))
+          continue;
+        if (exc && exc.test(p))
+          continue;
+        hits2.push({ path: p, line: Number(m[2]), text: m[4].slice(0, 400) });
+        if (hits2.length >= SEARCH_CONTENT_MAX_HITS) {
+          truncated2 = true;
+          break;
+        }
+      }
+      return { workspace: workspace3, query, matches: [], hits: hits2, truncated: truncated2 };
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        return { workspace: workspace3, query, matches: [], hits: [], truncated: false };
+      }
+    }
+    const matcher = buildLineMatcher(query, opts);
+    const hits = [];
+    let scanned = 0;
+    let truncated = false;
+    const deadline = Date.now() + SEARCH_DEADLINE_MS;
+    const queue = [base];
+    while (queue.length) {
+      if (Date.now() > deadline) {
+        truncated = true;
+        break;
+      }
+      const dir = queue.shift();
+      let dirents;
+      try {
+        dirents = await readdir4(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const d of dirents) {
+        if (Date.now() > deadline) {
+          truncated = true;
+          break;
+        }
+        if (++scanned > SEARCH_MAX_SCAN) {
+          truncated = true;
+          break;
+        }
+        if (d.isSymbolicLink())
+          continue;
+        const full = resolve3(dir, d.name);
+        if (d.isDirectory()) {
+          if (!SEARCH_SKIP_DIRS.has(d.name))
+            queue.push(full);
+          continue;
+        }
+        if (!d.isFile())
+          continue;
+        const rel = relative(root, full).split(sep).join("/");
+        if (inc && !inc.test(rel))
+          continue;
+        if (exc && exc.test(rel))
+          continue;
+        let info;
+        try {
+          info = await stat3(full);
+        } catch {
+          continue;
+        }
+        if (info.size > SEARCH_CONTENT_MAX_FILE)
+          continue;
+        let text;
+        try {
+          text = await readFile15(full, "utf8");
+        } catch {
+          continue;
+        }
+        if (text.includes("\x00"))
+          continue;
+        const lines = text.split(`
+`);
+        for (let i = 0;i < lines.length; i++) {
+          if (Date.now() > deadline) {
+            truncated = true;
+            break;
+          }
+          const line = lines[i];
+          if (matcher(line.length > LINE_MATCH_CAP ? line.slice(0, LINE_MATCH_CAP) : line)) {
+            hits.push({ path: rel, line: i + 1, text: line.slice(0, 400) });
+            if (hits.length >= SEARCH_CONTENT_MAX_HITS) {
+              truncated = true;
+              break;
+            }
+          }
+        }
+        if (truncated)
+          break;
+      }
+      if (truncated)
+        break;
+    }
+    return { workspace: workspace3, query, matches: [], hits, truncated };
   }
   async gitDiff(workspace3, relPath) {
     const { root, rel } = await this.resolve(workspace3, relPath);
     try {
-      await execFileAsync("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { maxBuffer: GIT_MAX_BUFFER });
+      await execFileAsync("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" });
     } catch {
       throw new Error("not-a-git-repo");
     }
     const files = [];
     try {
-      const { stdout: stdout2 } = await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "status", "--porcelain", "-z"], { maxBuffer: GIT_MAX_BUFFER });
+      const { stdout: stdout2 } = await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "status", "--porcelain", "-z"], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" });
       const fields = stdout2.split("\x00");
       for (let i = 0;i < fields.length; i++) {
         const field = fields[i];
@@ -33835,17 +34184,17 @@ class WorkspaceFs {
     const diffArgs = (base) => ["-C", root, ...base, ...rel ? ["--", rel] : []];
     let diff = "";
     try {
-      diff = (await execFileAsync("git", diffArgs(["diff", "HEAD"]), { maxBuffer: GIT_MAX_BUFFER })).stdout;
+      diff = (await execFileAsync("git", diffArgs(["diff", "HEAD"]), { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
     } catch {
       try {
-        diff = (await execFileAsync("git", diffArgs(["diff"]), { maxBuffer: GIT_MAX_BUFFER })).stdout;
+        diff = (await execFileAsync("git", diffArgs(["diff"]), { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
       } catch {
         diff = "";
       }
     }
     if (rel && !diff) {
       try {
-        diff = (await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "diff", "--no-index", "--", "/dev/null", rel], { maxBuffer: GIT_MAX_BUFFER })).stdout;
+        diff = (await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "diff", "--no-index", "--", "/dev/null", rel], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
       } catch (e) {
         const out = e.stdout;
         if (typeof out === "string")
@@ -33858,7 +34207,7 @@ class WorkspaceFs {
   async gitContext(root) {
     const run = async (...args) => {
       try {
-        return (await execFileAsync("git", ["-C", root, ...args], { maxBuffer: GIT_MAX_BUFFER })).stdout.trim();
+        return (await execFileAsync("git", ["-C", root, ...args], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout.trim();
       } catch {
         return null;
       }
@@ -33878,13 +34227,102 @@ class WorkspaceFs {
     return ctx;
   }
 }
-var execFileAsync, MAX_ENTRIES = 2000, FILE_READ_CAP, DIFF_CAP, GIT_MAX_BUFFER, SEARCH_MAX_RESULTS = 200, SEARCH_MAX_SCAN = 20000, SEARCH_SKIP_DIRS;
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function copyName(existing, name) {
+  const dot = name.lastIndexOf(".");
+  const hasExt = dot > 0;
+  const base = hasExt ? name.slice(0, dot) : name;
+  const ext = hasExt ? name.slice(dot) : "";
+  let candidate = `${base} copy${ext}`;
+  let n = 2;
+  while (existing.has(candidate))
+    candidate = `${base} copy ${n++}${ext}`;
+  return candidate;
+}
+function mimeForName(name) {
+  const dot = name.lastIndexOf(".");
+  const ext = dot > 0 ? name.slice(dot).toLowerCase() : "";
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+function buildMatcher(query, opts) {
+  return buildLineMatcher(query, opts);
+}
+function buildLineMatcher(query, opts) {
+  const flags = opts.matchCase ? "" : "i";
+  let pattern;
+  if (opts.regex)
+    pattern = query;
+  else
+    pattern = escapeRe(query);
+  if (opts.wholeWord)
+    pattern = `\\b${pattern}\\b`;
+  let re = null;
+  try {
+    re = new RegExp(pattern, flags);
+  } catch {
+    re = null;
+  }
+  if (!re) {
+    const needle = opts.matchCase ? query : query.toLowerCase();
+    return (s) => (opts.matchCase ? s : s.toLowerCase()).includes(needle);
+  }
+  return (s) => re.test(s);
+}
+function globToRegExp(glob) {
+  let re = "^";
+  for (let i = 0;i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (glob[i + 1] === "/")
+          i++;
+      } else
+        re += "[^/]*";
+    } else if (c === "?")
+      re += "[^/]";
+    else
+      re += escapeRe(c);
+  }
+  re += "$";
+  try {
+    return new RegExp(re);
+  } catch {
+    return /$^/;
+  }
+}
+var import_write_file_atomic3, execFileAsync, MAX_ENTRIES = 2000, FILE_READ_CAP, DIFF_CAP, GIT_MAX_BUFFER, SEARCH_MAX_RESULTS = 200, SEARCH_MAX_SCAN = 20000, SEARCH_SKIP_DIRS, SEARCH_CONTENT_MAX_HITS = 500, SEARCH_CONTENT_MAX_FILE, LINE_MATCH_CAP = 2000, DOWNLOAD_MAX, GIT_TIMEOUT_MS = 1e4, SEARCH_DEADLINE_MS = 4000, MIME_BY_EXT;
 var init_workspace_fs = __esm(() => {
+  import_write_file_atomic3 = __toESM(require_lib(), 1);
   execFileAsync = promisify(execFile);
   FILE_READ_CAP = 256 * 1024;
   DIFF_CAP = 512 * 1024;
   GIT_MAX_BUFFER = 32 * 1024 * 1024;
   SEARCH_SKIP_DIRS = new Set([".git", "node_modules"]);
+  SEARCH_CONTENT_MAX_FILE = 1024 * 1024;
+  DOWNLOAD_MAX = 5 * 1024 * 1024;
+  MIME_BY_EXT = {
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".json": "application/json",
+    ".js": "text/javascript",
+    ".ts": "text/plain",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".csv": "text/csv",
+    ".xml": "application/xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".pdf": "application/pdf",
+    ".zip": "application/zip"
+  };
 });
 
 // src/control/control-service.ts
@@ -33906,8 +34344,36 @@ class ControlService {
   workspaceGitDiff(workspace3, path16) {
     return this.workspaceFs.gitDiff(workspace3, path16);
   }
-  searchWorkspace(workspace3, query) {
-    return this.workspaceFs.search(workspace3, query);
+  searchWorkspace(workspace3, opts) {
+    return this.workspaceFs.search(workspace3, opts);
+  }
+  async fsCreate(workspace3, path16, kind) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return kind === "dir" ? this.workspaceFs.createDir(workspace3, path16) : this.workspaceFs.createFile(workspace3, path16);
+  }
+  async fsRename(workspace3, path16, newName) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return this.workspaceFs.rename(workspace3, path16, newName);
+  }
+  async fsDelete(workspace3, path16) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return this.workspaceFs.remove(workspace3, path16);
+  }
+  async fsCopy(workspace3, path16) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return this.workspaceFs.duplicate(workspace3, path16);
+  }
+  async fsWrite(workspace3, path16, content, expected) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return this.workspaceFs.writeFile(workspace3, path16, content, expected);
+  }
+  async fsDownload(workspace3, path16) {
+    return this.workspaceFs.readFileBytes(workspace3, path16);
   }
   async uploadFile(input) {
     return this.deps.uploadStore.save(input.filename, input.content, input.mimeType);
@@ -34445,7 +34911,7 @@ function realPtySpawn(file, args, opts) {
   return spawnPty2(file, args, opts);
 }
 function createTerminalService(deps) {
-  const spawn11 = deps.spawn ?? realPtySpawn;
+  const spawn12 = deps.spawn ?? realPtySpawn;
   const platform = deps.platform ?? process.platform;
   const sessions = new Map;
   const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
@@ -34471,7 +34937,7 @@ function createTerminalService(deps) {
       if (platform === "win32")
         throw new Error("terminal-unsupported-platform");
       const terminalId = randomUUID4();
-      const handle = spawn11(defaultShell(platform), [], { name: "xterm-256color", cols, rows, cwd, env: scrubEnv() });
+      const handle = spawn12(defaultShell(platform), [], { name: "xterm-256color", cols, rows, cwd, env: scrubEnv() });
       const session3 = { handle, seq: 0, idleTimer: null };
       sessions.set(terminalId, session3);
       handle.onData((data) => {
@@ -34545,7 +35011,7 @@ var init_terminal_service = __esm(() => {
 });
 
 // src/control/upload-store.ts
-import { mkdtemp as mkdtemp2, readdir as readdir5, rm as rm10, stat as stat4, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdtemp as mkdtemp2, readdir as readdir5, rm as rm11, stat as stat4, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
 import path16 from "node:path";
 function defaultRootDir() {
@@ -34581,11 +35047,11 @@ class UploadStore {
     if (bytes.byteLength > this.maxBytes)
       throw new Error("file-too-large");
     const safeName = sanitizeUploadFilename(filename);
-    const { mkdir: mkdir9 } = await import("node:fs/promises");
-    await mkdir9(this.rootDir, { recursive: true });
+    const { mkdir: mkdir10 } = await import("node:fs/promises");
+    await mkdir10(this.rootDir, { recursive: true });
     const dir = await mkdtemp2(path16.join(this.rootDir, "u-"));
     const filePath = path16.join(dir, safeName);
-    await writeFile8(filePath, bytes);
+    await writeFile9(filePath, bytes);
     return {
       id: path16.basename(dir),
       path: filePath,
@@ -34608,7 +35074,7 @@ class UploadStore {
       try {
         const info = await stat4(dir);
         if (info.mtimeMs < cutoff) {
-          await rm10(dir, { recursive: true, force: true });
+          await rm11(dir, { recursive: true, force: true });
           removed += 1;
         }
       } catch {}
@@ -34666,12 +35132,12 @@ var init_agent_catalog = __esm(() => {
 
 // src/config/config-watcher.ts
 import { watch } from "node:fs";
-import { basename as basename3, dirname as dirname12 } from "node:path";
+import { basename as basename4, dirname as dirname13 } from "node:path";
 function startConfigWatcher(options) {
   const { configPath, onChange, debounceMs = 250, logger: logger2 } = options;
   const watchFactory = options.watchFactory ?? watch;
-  const dir = dirname12(configPath);
-  const target = basename3(configPath);
+  const dir = dirname13(configPath);
+  const target = basename4(configPath);
   let timer;
   let watcher;
   const fire = () => {
@@ -34686,7 +35152,7 @@ function startConfigWatcher(options) {
   };
   try {
     watcher = watchFactory(dir, { persistent: false }, (_event, filename) => {
-      if (filename !== null && basename3(filename.toString()) !== target)
+      if (filename !== null && basename4(filename.toString()) !== target)
         return;
       if (timer)
         clearTimeout(timer);
@@ -34726,7 +35192,7 @@ __export(exports_main, {
 });
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { homedir as homedir14 } from "node:os";
-import { dirname as dirname13, join as join23 } from "node:path";
+import { dirname as dirname14, join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function startProgressHeartbeat(orchestration3, config4, logger2, channel) {
   const thresholdSeconds = config4.orchestration.progressHeartbeatSeconds;
@@ -35271,7 +35737,8 @@ async function buildApp(paths, deps = {}) {
     },
     uploadStore,
     terminal: terminalService,
-    terminalEnabled: () => terminalEnabled(config4)
+    terminalEnabled: () => terminalEnabled(config4),
+    filesWriteEnabled: () => filesWriteEnabled(config4)
   });
   const workspaceSignature = (cfg) => JSON.stringify(Object.keys(cfg.workspaces).sort().map((name) => {
     const ws = cfg.workspaces[name];
@@ -35424,7 +35891,7 @@ async function main() {
   }
 }
 async function prepareChannelMedia(configPath, config4) {
-  const runtimeDir = join23(dirname13(configPath), "runtime");
+  const runtimeDir = join23(dirname14(configPath), "runtime");
   const mediaRootDir = join23(runtimeDir, "media");
   const mediaStore = new RuntimeMediaStore({ rootDir: mediaRootDir });
   await mediaStore.cleanupExpired().catch((error2) => {
@@ -35439,7 +35906,7 @@ function resolveRuntimePaths() {
     throw new Error("Unable to resolve the current user home directory");
   }
   const configPath = coreEnv("CONFIG") ?? join23(coreHomeDir(home), "config.json");
-  const runtimeDir = join23(dirname13(configPath), "runtime");
+  const runtimeDir = join23(dirname14(configPath), "runtime");
   return {
     configPath,
     statePath: coreEnv("STATE") ?? join23(coreHomeDir(home), "state.json"),
@@ -35454,12 +35921,12 @@ function resolveBridgeEntryPath() {
   return fileURLToPath5(new URL("./bridge/bridge-main.ts", import.meta.url));
 }
 function resolveAppLogPath(configPath) {
-  const rootDir = dirname13(configPath);
+  const rootDir = dirname14(configPath);
   const runtimeDir = join23(rootDir, "runtime");
   return join23(runtimeDir, "app.log");
 }
 function resolvePerfLogPath(configPath) {
-  const rootDir = dirname13(configPath);
+  const rootDir = dirname14(configPath);
   const runtimeDir = join23(rootDir, "runtime");
   return join23(runtimeDir, "perf.log");
 }
@@ -35517,7 +35984,7 @@ var init_main = __esm(async () => {
 });
 
 // src/doctor/checks/acpx-check.ts
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn12 } from "node:child_process";
 async function checkAcpx(options = {}) {
   const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
   try {
@@ -35564,7 +36031,7 @@ function buildDetails(metadata, version2, verbose) {
 async function defaultRunVersion(command) {
   const spawnSpec = resolveSpawnCommand(command, ["--version"]);
   return await new Promise((resolve4, reject) => {
-    const child = spawn11(spawnSpec.command, spawnSpec.args, {
+    const child = spawn12(spawnSpec.command, spawnSpec.args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout2 = "";
@@ -35702,7 +36169,7 @@ var init_config_check = __esm(async () => {
 });
 
 // src/doctor/checks/daemon-check.ts
-import { readdir as readdir6, readFile as readFile15, rm as rm11 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile16, rm as rm12 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { homedir as homedir15 } from "node:os";
 import { join as join24 } from "node:path";
@@ -35848,7 +36315,7 @@ async function defaultListConsumerLocks(runtimeDir) {
 }
 async function defaultReadConsumerLock(path17) {
   try {
-    const raw = await readFile15(path17, "utf8");
+    const raw = await readFile16(path17, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.pid === "number" ? { pid: parsed.pid } : null;
   } catch {
@@ -35856,7 +36323,7 @@ async function defaultReadConsumerLock(path17) {
   }
 }
 async function defaultRemoveConsumerLock(path17) {
-  await rm11(path17, { force: true });
+  await rm12(path17, { force: true });
 }
 function resolveCliEntryPath() {
   return process.argv[1] ?? fileURLToPath6(import.meta.url);
@@ -35872,7 +36339,7 @@ var init_daemon_check = __esm(() => {
 
 // src/doctor/checks/logs-check.ts
 import { stat as stat5, readdir as readdir7 } from "node:fs/promises";
-import { basename as basename4, join as join25 } from "node:path";
+import { basename as basename5, join as join25 } from "node:path";
 import { homedir as homedir16 } from "node:os";
 async function checkLogs(options = {}) {
   const home = options.home ?? process.env.HOME ?? homedir16();
@@ -35902,7 +36369,7 @@ async function checkLogs(options = {}) {
       `error: ${formatError6(error2)}`
     ]);
   }
-  const baseNames = [basename4(paths.appLog), basename4(paths.stdoutLog), basename4(paths.stderrLog)];
+  const baseNames = [basename5(paths.appLog), basename5(paths.stdoutLog), basename5(paths.stderrLog)];
   const tracked = new Set(baseNames);
   const matched = entries.filter((entry) => isTrackedLogName(entry, tracked));
   const files = [];
@@ -36233,7 +36700,7 @@ var init_plugin_check = __esm(async () => {
 // src/doctor/checks/runtime-check.ts
 import { constants } from "node:fs";
 import { access as access4, stat as stat6 } from "node:fs/promises";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 import { homedir as homedir18 } from "node:os";
 async function checkRuntime(options = {}) {
   const home = options.home ?? process.env.HOME ?? homedir18();
@@ -36389,7 +36856,7 @@ async function checkFileCreatable(label, path17, probe, platform) {
         detail: `${label}: ${path17} (unusable: ${formatError9(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(dirname14(path17), probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(dirname15(path17), probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
@@ -36425,7 +36892,7 @@ async function checkCreatableAncestorDirectory(path17, probe, platform) {
         blockingPath: path17
       };
     }
-    const parent = dirname14(path17);
+    const parent = dirname15(path17);
     if (parent === path17) {
       return {
         ok: false,
@@ -37210,7 +37677,7 @@ var init_doctor2 = __esm(async () => {
 init_core_home();
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { homedir as homedir20 } from "node:os";
-import { dirname as dirname15, join as join27, sep as sep2 } from "node:path";
+import { dirname as dirname16, join as join27, sep as sep2 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // src/runtime/migrate-core-home.ts
@@ -53839,7 +54306,7 @@ function safeDaemonLogPaths() {
     const configPath = resolveConfigPathForCurrentEnv();
     const paths = resolveDaemonPathsForCurrentConfig();
     return {
-      appLog: join27(dirname15(configPath), "runtime", "app.log"),
+      appLog: join27(dirname16(configPath), "runtime", "app.log"),
       stderrLog: paths.stderrLog
     };
   } catch {

package/dist/config/types.d.ts

@@ -48,6 +48,11 @@ export interface TerminalConfig {
     /** Idle seconds before a terminal PTY is auto-killed. Defaults to 900 (15 min). */
     idleTimeoutSeconds?: number;
 }
+export interface FilesConfig {
+    /** Default false. When false, all fs write ops (new/rename/delete/copy) are rejected
+     *  before touching disk. Download is a read and stays available regardless. */
+    writeEnabled: boolean;
+}
 export type LoggingLevel = "error" | "info" | "debug";
 export interface PerfLogConfig {
     enabled: boolean;
@@ -110,6 +115,8 @@ export interface AppConfig {
     later?: LaterConfig;
     language?: Locale;
     terminal?: TerminalConfig;
+    files?: FilesConfig;
 }
 export declare function terminalEnabled(config: AppConfig): boolean;
 export declare function terminalIdleTimeoutSeconds(config: AppConfig): number;
+export declare function filesWriteEnabled(config: AppConfig): boolean;

package/dist/control/control-service.d.ts

@@ -8,7 +8,7 @@ import type { CancelTaskInput, OrchestrationService, OrchestrationTaskFilter } f
 import type { OrchestrationTaskRecord } from "../orchestration/orchestration-types";
 import type { ControlEventBus } from "./control-event-bus";
 import type { AgentCatalogEntry } from "../config/agent-catalog";
-import { type DirListing, type FileContent, type SearchResult, type WorkspaceDiff } from "./workspace-fs";
+import { type DirListing, type FileContent, type SearchOptions, type SearchResult, type WorkspaceDiff } from "./workspace-fs";
 import type { PromptAttachmentRef } from "@ganglion/xacpx-relay-protocol";
 import type { UploadStore } from "./upload-store.js";
 export interface ControlSessionInfo {
@@ -79,6 +79,7 @@ export interface ControlServiceDeps {
     uploadStore: UploadStore;
     terminal: import("./terminal-service").TerminalService;
     terminalEnabled: () => boolean;
+    filesWriteEnabled: () => boolean;
 }
 export interface ControlPromptInput {
     chatKey: string;
@@ -138,7 +139,33 @@ export declare class ControlService {
     listDirectory(workspace: string, path?: string): Promise<DirListing>;
     readWorkspaceFile(workspace: string, path: string): Promise<FileContent>;
     workspaceGitDiff(workspace: string, path?: string): Promise<WorkspaceDiff>;
-    searchWorkspace(workspace: string, query: string): Promise<SearchResult>;
+    searchWorkspace(workspace: string, opts: SearchOptions): Promise<SearchResult>;
+    fsCreate(workspace: string, path: string, kind: "file" | "dir"): Promise<{
+        path: string;
+    }>;
+    fsRename(workspace: string, path: string, newName: string): Promise<{
+        path: string;
+    }>;
+    fsDelete(workspace: string, path: string): Promise<{
+        path: string;
+    }>;
+    fsCopy(workspace: string, path: string): Promise<{
+        path: string;
+    }>;
+    fsWrite(workspace: string, path: string, content: string, expected: {
+        mtimeMs: number;
+        size: number;
+    }): Promise<{
+        path: string;
+        mtimeMs: number;
+        size: number;
+    }>;
+    fsDownload(workspace: string, path: string): Promise<{
+        path: string;
+        base64: string;
+        size: number;
+        mimeType: string;
+    }>;
     uploadFile(input: {
         filename: string;
         content: string;

package/dist/control/workspace-fs.d.ts

@@ -2,17 +2,24 @@ export interface FsEntry {
     name: string;
     type: "dir" | "file";
     size?: number;
+    /** True when git check-ignore matches this entry (omitted in non-git workspaces). */
+    ignored?: boolean;
 }
 export interface DirListing {
     workspace: string;
     path: string;
     entries: FsEntry[];
+    /** Absolute realpath'd workspace root on the connector host. */
+    root: string;
+    /** Host path separator, so the client can render an absolute host path. */
+    sep: "/" | "\\";
 }
 export interface FileContent {
     workspace: string;
     path: string;
     content: string;
     size: number;
+    mtimeMs: number;
     truncated: boolean;
     binary: boolean;
 }
@@ -20,12 +27,31 @@ export interface DiffFile {
     path: string;
     status: string;
 }
+export interface SearchHit {
+    path: string;
+    line: number;
+    text: string;
+}
 export interface SearchResult {
     workspace: string;
     query: string;
     matches: string[];
+    hits: SearchHit[];
     truncated: boolean;
 }
+export interface SearchOptions {
+    query: string;
+    mode?: "name" | "content";
+    matchCase?: boolean;
+    wholeWord?: boolean;
+    regex?: boolean;
+    /** Glob to restrict matches (relative to workspace root). */
+    include?: string;
+    /** Glob to drop matches. */
+    exclude?: string;
+    /** Base directory (relative) to scope the search; defaults to the whole workspace. */
+    path?: string;
+}
 export interface WorkspaceDiff {
     workspace: string;
     files: DiffFile[];
@@ -51,14 +77,69 @@ export declare class WorkspaceFs {
     /** Resolve `relPath` within a named workspace, symlink-safe and contained. Throws
      *  on unknown workspace, missing target, or any path that escapes the root. */
     private resolve;
+    /** Resolve the PARENT directory of a to-be-created/renamed target. Parent must exist
+     *  and be contained; the final segment is validated (non-empty, no separators, not
+     *  "."/".."). Because parent is realpath'd+contained and name has no separator, the
+     *  join target stays inside the workspace root. */
+    private resolveParent;
+    createFile(workspace: string, relPath: string): Promise<{
+        path: string;
+    }>;
+    createDir(workspace: string, relPath: string): Promise<{
+        path: string;
+    }>;
+    rename(workspace: string, relPath: string, newName: string): Promise<{
+        path: string;
+    }>;
+    duplicate(workspace: string, relPath: string): Promise<{
+        path: string;
+    }>;
+    remove(workspace: string, relPath: string): Promise<{
+        path: string;
+    }>;
+    readFileBytes(workspace: string, relPath: string): Promise<{
+        path: string;
+        base64: string;
+        size: number;
+        mimeType: string;
+    }>;
     listDirectory(workspace: string, relPath?: string): Promise<DirListing>;
+    /** Return the subset of the given root-relative paths that git considers ignored.
+     *  Uses `check-ignore -z --stdin` (bounded by the caller's MAX_ENTRIES listing).
+     *  Any git error (not a repo, git missing) yields an empty set — callers degrade to
+     *  "nothing ignored". Never throws. */
+    private gitCheckIgnore;
     readFile(workspace: string, relPath: string): Promise<FileContent>;
-    /** Find files whose relative path contains `query` (case-insensitive). Walks the
-     *  tree breadth-first, skipping `.git`/`node_modules` and never following symlinks
-     *  (so it stays contained), bounded by a scan budget and a result cap. */
-    search(workspace: string, query: string): Promise<SearchResult>;
+    /** Overwrite an EXISTING file's content, guarded by a stale-write token. The target must
+     *  resolve inside the workspace (realpath containment), be a regular file, and match the
+     *  caller's `{mtimeMs,size}` token — otherwise `stale-write`. Content must be UTF-8 text
+     *  (no NUL) and within the read cap. Writes atomically. Returns a fresh token. */
+    writeFile(workspace: string, relPath: string, content: string, expected: {
+        mtimeMs: number;
+        size: number;
+    }): Promise<{
+        path: string;
+        mtimeMs: number;
+        size: number;
+    }>;
+    /** Find files by name (default) or content. Name mode walks relative paths
+     *  breadth-first, skipping `.git`/`node_modules` and never following symlinks (so it
+     *  stays contained), applying the query plus any include/exclude globs. Content mode
+     *  delegates to `contentGrep`. Both are bounded by a scan budget and a result cap. */
+    search(workspace: string, opts: SearchOptions): Promise<SearchResult>;
+    /** Content grep: `git grep` when the workspace root is a git repo (fast, respects
+     *  .gitignore), else a bounded manual walk that scans each file line by line. Never
+     *  throws on git absence/failure or an invalid user regex — both degrade gracefully.
+     *  `scopeRel` is the already-resolved (canonicalized, containment-checked) scope from
+     *  `resolve()`; include/exclude are applied as a post-filter on the parsed hits rather
+     *  than as extra git pathspecs — git ORs multiple positive pathspecs together, so a
+     *  scope pathspec plus an include pathspec would leak matches from outside the scope. */
+    private contentGrep;
     gitDiff(workspace: string, relPath?: string): Promise<WorkspaceDiff>;
     /** Branch + worktree context for a repo root. Best-effort: any git hiccup just
      *  omits the fields so the diff itself still returns. */
     private gitContext;
 }
+/** First free "NAME copy", "NAME copy 2"… inserting before the extension. Dotfiles
+ *  (leading dot, no other dot) and extension-less names get no split. */
+export declare function copyName(existing: Set<string>, name: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/xacpx",
-  "version": "0.17.0-beta.1",
+  "version": "0.17.0-beta.3",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",