dsh-remote-file-system 0.0.1 → 0.1.1

package/lib/index.js

@@ -0,0 +1,1002 @@
+// src/remote-fs.ts
+import {
+  FsError as FsError2,
+  FsTargetKey,
+  FsVersion
+} from "@deepseek-ai/dsh-fs";
+
+// src/protocol.ts
+import { spawn } from "node:child_process";
+import { FsError } from "@deepseek-ai/dsh-fs";
+var ERR_PREFIX = "__ERR__";
+function b64(input) {
+  return Buffer.from(input, "utf8").toString("base64");
+}
+var PATH_PROLOGUE = [
+  "set +e",
+  'b64d() { printf %s "$1" | base64 -d 2>/dev/null; }',
+  'P=$(b64d "$RM_PATH")',
+  'case "$P" in "~"*) eval "P="$P"" ;; esac'
+].join("\n");
+function envPrefix(env) {
+  return Object.entries(env).map(([k, v]) => k + "='" + v + "'").join(" ") + " bash -s";
+}
+async function sshExec(alias, env, scriptBody, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  return await new Promise((resolve, reject) => {
+    const child = spawn("ssh", [
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "ConnectTimeout=" + Math.max(1, Math.floor(timeoutMs / 1e3)),
+      alias,
+      envPrefix(env)
+    ], { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (d) => {
+      stdout += d;
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d;
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error("ssh 连接失败：" + err.message));
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ exitCode: timedOut ? -1 : code, stdout, stderr });
+    });
+    child.stdin.write(scriptBody);
+    child.stdin.end();
+  });
+}
+async function sshOutcome(alias, env, scriptBody, opts = {}) {
+  const raw = await sshExec(alias, env, scriptBody, opts).catch((e) => {
+    throw new FsError(e.message, "FS_IO_ERROR");
+  });
+  if (raw.exitCode === -1) throw new FsError("远程执行超时", "FS_IO_ERROR");
+  if (raw.exitCode === 0) return { code: "OK", stdout: raw.stdout };
+  const line = raw.stderr.split("\n").find((l) => l.startsWith(ERR_PREFIX));
+  if (line) {
+    const rest = line.slice(ERR_PREFIX.length);
+    const sep = rest.indexOf("__");
+    const code = sep === -1 ? "FS_IO_ERROR" : rest.slice(0, sep);
+    const message = sep === -1 ? rest : rest.slice(sep + 2);
+    throw new FsError(message || "远程执行失败", code === "FS_IO_ERROR" ? "FS_IO_ERROR" : code);
+  }
+  const detail = raw.stderr.trim() || "远程执行失败且无输出";
+  throw new FsError(detail, "FS_IO_ERROR");
+}
+var DIE_HELPER = [
+  'die() { local c="$1"; shift; local m="$*"; echo "__ERR__${c}__${m}" >&2; exit 1; }'
+].join("\n");
+var B64_HELPER = [
+  'b64out() { printf %s "$1" | base64 -w0 2>/dev/null; }'
+].join("\n");
+
+// src/remote-fs.ts
+var TAILS = /* @__PURE__ */ new Map();
+async function withLock(key, fn) {
+  const prev = TAILS.get(key) ?? Promise.resolve();
+  const run = prev.then(() => fn());
+  TAILS.set(key, run.catch(() => {
+  }));
+  return run;
+}
+var ALIAS_RE = /^[A-Za-z0-9._-]+$/;
+function splitAliasPath(filePath) {
+  const idx = filePath.indexOf(":");
+  if (idx <= 0) throw new FsError2("file_path 须为「别名:路径」形式，缺少别名前缀：" + filePath, "FS_IO_ERROR");
+  const alias = filePath.slice(0, idx);
+  const rawPath = filePath.slice(idx + 1);
+  if (!ALIAS_RE.test(alias)) throw new FsError2("非法的别名前缀：" + alias, "FS_IO_ERROR");
+  if (!(rawPath.startsWith("/") || rawPath.startsWith("~/"))) {
+    throw new FsError2("远程路径只接受绝对路径或 ~/ 开头，收到相对路径：" + rawPath, "FS_IO_ERROR");
+  }
+  return { alias, rawPath };
+}
+var RemoteFileSystem = class {
+  /** 单次读取字节上限，超限拒绝且不做流式，见 DESIGN §7 资源上限。 */
+  readMaxBytes = 50 * 1024 * 1024;
+  /** 解析「别名:路径」为稳定 FsTarget。targetKey 含 alias 与 rawPath，displayPath 即原名。 */
+  async resolve(path) {
+    const { alias, rawPath } = splitAliasPath(path);
+    const displayPath = alias + ":" + rawPath;
+    return { targetKey: FsTargetKey(alias + "::" + rawPath), displayPath };
+  }
+  /** FileSystem 同形占位：无进程内路径，返回 displayPath。 */
+  processPath(target) {
+    return target.displayPath;
+  }
+  /** stat：类型 + size + 版本依据，缺失返回 undefined。版本只作 host 进程内陈旧排序。 */
+  async stat(target) {
+    return withLock(target.targetKey, () => this.statLocked(target));
+  }
+  async statLocked(target) {
+    const { alias, rawPath } = splitAliasPath(target.displayPath);
+    const env = { RM_PATH: b64(rawPath) };
+    const action = [
+      PATH_PROLOGUE,
+      DIE_HELPER,
+      'if [ ! -e "$P" ] && [ ! -L "$P" ]; then echo ABSENT; exit 0; fi',
+      'if [ -L "$P" ]; then echo OTHER; exit 0; fi',
+      'if [ -d "$P" ]; then echo DIR; exit 0; fi',
+      'if [ ! -f "$P" ]; then echo OTHER; exit 0; fi',
+      'SIZE=$(wc -c < "$P" 2>/dev/null | tr -d " ")',
+      'MT=$(stat -c %Y "$P" 2>/dev/null || echo 0)',
+      'echo "FILE:$SIZE:$MT"'
+    ].join("\n");
+    const out = await sshOutcome(alias, env, action);
+    const s = out.stdout.trim();
+    if (s === "ABSENT") return void 0;
+    if (s === "DIR") return { version: FsVersion("dir:" + Date.now()), type: "directory" };
+    if (s === "OTHER") return { version: FsVersion("other:" + Date.now()), type: "other" };
+    const m = /^FILE:(\d*):(\d*)$/.exec(s);
+    const size = m && m[1] !== "" ? Number(m[1]) : void 0;
+    const mtime = m && m[2] !== "" ? m[2] : "0";
+    return {
+      version: FsVersion("m:" + mtime + (size !== void 0 ? ":" + size : "")),
+      type: "file",
+      ...size !== void 0 ? { size } : {}
+    };
+  }
+  /** 读整文件 utf8。缺失归 FS_NOT_FOUND，非普通归 FS_NOT_REGULAR_FILE，超限归 FS_TOO_LARGE。 */
+  async readText(target) {
+    return withLock(target.targetKey, () => this.readTextLocked(target));
+  }
+  async readTextLocked(target) {
+    const { alias, rawPath } = splitAliasPath(target.displayPath);
+    const env = { RM_PATH: b64(rawPath), RM_MAX: String(this.readMaxBytes) };
+    const action = [
+      PATH_PROLOGUE,
+      DIE_HELPER,
+      'if [ ! -e "$P" ] && [ ! -L "$P" ]; then die FS_NOT_FOUND 文件不存在; exit 0; fi',
+      'if [ -d "$P" ]; then die FS_NOT_REGULAR_FILE 目标是一个目录; exit 0; fi',
+      'if [ ! -f "$P" ]; then die FS_NOT_REGULAR_FILE 目标不是普通文件; exit 0; fi',
+      'SIZE=$(wc -c < "$P" 2>/dev/null | tr -d " ")',
+      'if [ -n "$SIZE" ] && [ "$SIZE" -gt "$RM_MAX" ] 2>/dev/null; then die FS_TOO_LARGE 文件超过单次读取上限，不做流式; exit 0; fi',
+      'base64 -w0 < "$P" 2>/dev/null || die FS_IO_ERROR 读取内容失败'
+    ].join("\n");
+    const out = await sshOutcome(alias, env, action);
+    return Buffer.from(out.stdout.replace(/\s+$/u, ""), "base64").toString("utf8");
+  }
+  /** readBytes：raw 读取，文本只读，返回 utf8 字节。 */
+  async readBytes(target, maxBytes) {
+    const text = await this.readText(target);
+    const buf = Buffer.from(text, "utf8");
+    if (buf.byteLength > maxBytes) throw new FsError2("超出字节上限", "FS_TOO_LARGE");
+    return buf;
+  }
+  /**
+   * 全文件写，恒用 createIfAbsent，只新建。目标已存在即 FS_NOT_OBSERVED，绝无覆写。
+   * 只接受 createIfAbsent 意图，其他拒绝。
+   */
+  async writeText(target, content, expected) {
+    return withLock(target.targetKey, () => this.writeTextLocked(target, content, expected));
+  }
+  async writeTextLocked(target, content, expected) {
+    const { alias, rawPath } = splitAliasPath(target.displayPath);
+    if (expected !== void 0 && expected.kind !== "createIfAbsent") {
+      throw new FsError2("write_remote 只允许新建，仅支持 createIfAbsent 意图", "FS_NOT_OBSERVED");
+    }
+    const env = { RM_PATH: b64(rawPath), RM_DATA: b64(content) };
+    const action = [
+      PATH_PROLOGUE,
+      DIE_HELPER,
+      'TMP=$(mktemp "$P.XXXXXXXX.tmp" 2>/dev/null)',
+      'if [ -z "$TMP" ]; then die FS_IO_ERROR 无法创建临时文件，目录可能不可写; exit 0; fi',
+      'printf %s "$(b64d "$RM_DATA")" > "$TMP" 2>/dev/null || { rm -f "$TMP"; die FS_IO_ERROR 写入临时文件失败; exit 0; }',
+      'if [ -e "$P" ] || [ -L "$P" ]; then rm -f "$TMP"; die FS_NOT_OBSERVED 文件已存在，write_remote 只允许新建; exit 0; fi',
+      'mv -f "$TMP" "$P" 2>/dev/null || { rm -f "$TMP"; die FS_IO_ERROR mv 发布失败; exit 0; }',
+      "echo OK"
+    ].join("\n");
+    await sshOutcome(alias, env, action);
+    return { operation: "create", version: FsVersion("w:" + Date.now()), before: null, after: content };
+  }
+  /** 编辑后写回，整块替换。 */
+  async writeReplaced(target, content) {
+    const { alias, rawPath } = splitAliasPath(target.displayPath);
+    const env = { RM_PATH: b64(rawPath), RM_DATA: b64(content) };
+    const action = [
+      PATH_PROLOGUE,
+      DIE_HELPER,
+      'TMP=$(mktemp "$P.XXXXXXXX.tmp" 2>/dev/null)',
+      'if [ -z "$TMP" ]; then die FS_IO_ERROR 无法创建临时文件; exit 0; fi',
+      'printf %s "$(b64d "$RM_DATA")" > "$TMP" 2>/dev/null || { rm -f "$TMP"; die FS_IO_ERROR 写入临时文件失败; exit 0; }',
+      'if [ ! -e "$P" ]; then rm -f "$TMP"; die FS_NOT_FOUND 文件已不存在; exit 0; fi',
+      'mv -f "$TMP" "$P" 2>/dev/null || { rm -f "$TMP"; die FS_IO_ERROR mv 替换失败; exit 0; }',
+      "echo OK"
+    ].join("\n");
+    await sshOutcome(alias, env, action);
+    return content;
+  }
+  /**
+   * 字面编辑：读原文 → host 内唯一匹配或全替换 → 写回。匹配类错误走原生词表，即 FS_AMBIGUOUS_EDIT 与 FS_EDIT_NOT_FOUND；远端失败归远程失败类。
+   * 整块读改写，保留远端换行。
+   */
+  async editText(target, edit, _expected) {
+    return withLock(target.targetKey, async () => {
+      const { alias, rawPath } = splitAliasPath(target.displayPath);
+      const readTarget = { targetKey: target.targetKey, displayPath: alias + ":" + rawPath };
+      const before = await this.readTextLocked(readTarget);
+      const matches = this.countMatches(before, edit.oldString);
+      if (matches === 0) throw new FsError2("old_string 未命中任何匹配", "FS_EDIT_NOT_FOUND");
+      if (!edit.replaceAll && matches > 1) {
+        throw new FsError2("old_string 出现 " + matches + " 次，需更精确或设 replace_all", "FS_AMBIGUOUS_EDIT");
+      }
+      const after = edit.replaceAll ? before.split(edit.oldString).join(edit.newString) : before.replace(edit.oldString, edit.newString);
+      await this.writeReplaced(readTarget, after);
+      return { version: FsVersion("e:" + Date.now()), before, after };
+    });
+  }
+  countMatches(text, oldString) {
+    if (oldString === "") return 0;
+    let count = 0;
+    let idx = text.indexOf(oldString);
+    while (idx !== -1) {
+      count++;
+      idx = text.indexOf(oldString, idx + oldString.length);
+    }
+    return count;
+  }
+};
+
+// src/read.ts
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { FsError as FsError4 } from "@deepseek-ai/dsh-fs";
+
+// src/render.ts
+import { FsError as FsError3 } from "@deepseek-ai/dsh-fs";
+
+// node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+
+// src/render.ts
+function truncateLine(line, maxLineLength) {
+  return line.length > maxLineLength ? line.substring(0, maxLineLength) + "... (line truncated to " + maxLineLength + " chars)" : line;
+}
+function stripCarriageReturn(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function buildWindow(text, request, displayPath) {
+  const linesOut = [];
+  let totalLines = 0;
+  let truncatedByBytes = false;
+  let outputBytes = 0;
+  const parts = text.split("\n");
+  const hasTrailingNewline = text.endsWith("\n");
+  const meaningful = hasTrailingNewline ? parts.slice(0, -1) : parts;
+  if (text.length === 0) {
+    return { lines: [], totalLines: 0, truncatedByBytes: false };
+  }
+  totalLines = meaningful.length;
+  for (let i = 0; i < meaningful.length; i += 1) {
+    const raw = meaningful[i];
+    if (truncatedByBytes) break;
+    const lineNumber = i + 1;
+    if (lineNumber < request.offset || linesOut.length >= request.limit) continue;
+    const shown = truncateLine(stripCarriageReturn(raw), request.maxLineLength);
+    const bytes = Buffer.byteLength(shown, "utf8") + (linesOut.length > 0 ? 1 : 0);
+    if (outputBytes + bytes > request.maxBytes) {
+      truncatedByBytes = true;
+      break;
+    }
+    outputBytes += bytes;
+    linesOut.push({ number: lineNumber, text: shown });
+  }
+  if (!truncatedByBytes && request.offset > totalLines && !(totalLines === 0 && request.offset === 1)) {
+    throw new FsError3("offset " + request.offset + ' is out of range for "' + displayPath + '" (' + totalLines + " lines)", "FS_NOT_FOUND");
+  }
+  return { lines: linesOut, totalLines, truncatedByBytes };
+}
+function formatReadOutput(displayPath, outcome) {
+  const endLine = outcome.lines.at(-1)?.number ?? Math.max(0, outcome.offset - 1);
+  let footer;
+  if (outcome.truncatedByBytes) {
+    footer = "(Output capped. Showing lines " + outcome.offset + "-" + endLine + ". Use offset=" + (endLine + 1) + " to continue.)";
+  } else if (endLine < outcome.totalLines) {
+    footer = "(Showing lines " + outcome.offset + "-" + endLine + " of " + outcome.totalLines + ". Use offset=" + (endLine + 1) + " to continue.)";
+  } else {
+    footer = "(End of file - total " + outcome.totalLines + " lines)";
+  }
+  const body = outcome.lines.length > 0 ? outcome.lines.map((line) => line.number + ": " + line.text).join("\n") + "\n\n" + footer : footer;
+  return "<path>" + displayPath + "</path>\n<type>file</type>\n<content>\n" + body + "\n</content>";
+}
+var LANG_BY_EXTENSION = {
+  ts: "ts",
+  tsx: "tsx",
+  mts: "ts",
+  cts: "ts",
+  js: "js",
+  jsx: "jsx",
+  mjs: "js",
+  cjs: "js",
+  json: "json",
+  jsonc: "json",
+  py: "py",
+  rb: "rb",
+  go: "go",
+  rs: "rs",
+  java: "java",
+  c: "c",
+  h: "c",
+  cc: "cpp",
+  cpp: "cpp",
+  hpp: "cpp",
+  cxx: "cpp",
+  cs: "cs",
+  kt: "kotlin",
+  swift: "swift",
+  php: "php",
+  sh: "sh",
+  bash: "sh",
+  zsh: "sh",
+  yaml: "yaml",
+  yml: "yaml",
+  toml: "toml",
+  ini: "ini",
+  md: "md",
+  markdown: "md",
+  mdx: "mdx",
+  html: "html",
+  htm: "html",
+  css: "css",
+  scss: "scss",
+  less: "less",
+  sql: "sql",
+  xml: "xml",
+  lua: "lua"
+};
+function langFromPath(path) {
+  const base = path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return void 0;
+  const ext = base.slice(dot + 1).toLowerCase();
+  return Object.hasOwn(LANG_BY_EXTENSION, ext) ? LANG_BY_EXTENSION[ext] : void 0;
+}
+function readMetaFromMeta(meta) {
+  if (typeof meta !== "object" || meta === null || Array.isArray(meta)) return void 0;
+  const m = meta;
+  const { path, offset, lines, totalLines, lang } = m;
+  if (typeof path !== "string" || typeof totalLines !== "number" || typeof offset !== "number") return void 0;
+  if (!Number.isInteger(offset) || offset < 1) return void 0;
+  if (!Number.isInteger(totalLines) || totalLines < 0) return void 0;
+  if (!Array.isArray(lines) || !lines.every((l) => l !== null && typeof l === "object" && !Array.isArray(l) && typeof l.number === "number" && Number.isInteger(l.number) && l.number >= 1 && typeof l.text === "string")) return void 0;
+  if (lang !== void 0 && typeof lang !== "string") return void 0;
+  const typed = lines;
+  let prev = offset - 1;
+  for (const { number } of typed) {
+    if (number <= prev || number > totalLines) return void 0;
+    prev = number;
+  }
+  return { path, offset, lines: typed, totalLines, ...lang === void 0 ? {} : { lang } };
+}
+function computeHunkDiffs(path, before, after) {
+  const patch = structuredPatch("", "", before, after, void 0, void 0, { context: 3 });
+  const diffs = [];
+  for (const hunk of patch.hunks) {
+    const oldLines = [];
+    const newLines = [];
+    for (const line of hunk.lines) {
+      if (line.startsWith("\\")) continue;
+      const text = line.slice(1);
+      if (line.startsWith("-")) oldLines.push(text);
+      else if (line.startsWith("+")) newLines.push(text);
+      else {
+        oldLines.push(text);
+        newLines.push(text);
+      }
+    }
+    diffs.push({ path, oldText: oldLines.length > 0 ? oldLines.join("\n") : null, newText: newLines.join("\n") });
+  }
+  return diffs;
+}
+function diffsFromMeta(meta) {
+  if (typeof meta !== "object" || meta === null || Array.isArray(meta)) return void 0;
+  const diffs = meta.diffs;
+  if (!Array.isArray(diffs) || diffs.length === 0) return void 0;
+  const valid = diffs.every((d) => d !== null && typeof d === "object" && !Array.isArray(d) && typeof d.path === "string" && (d.oldText === null || typeof d.oldText === "string") && typeof d.newText === "string");
+  return valid ? diffs : void 0;
+}
+function formatWriteOutput(displayPath, operation) {
+  const verb = operation === "create" ? "Created" : "Updated";
+  return "<path>" + displayPath + "</path>\n<type>file</type>\n<content>\n" + verb + " file\n</content>";
+}
+function formatEditOutput(displayPath, replaceAll) {
+  return replaceAll ? "The file " + displayPath + " has been updated. All occurrences were successfully replaced." : "The file " + displayPath + " has been updated successfully.";
+}
+
+// src/read.ts
+var READ_LIMIT = 2e3;
+var READ_MAX_LINE_LENGTH = 2e3;
+var READ_MAX_BYTES = 50 * 1024;
+function parsePositiveInteger(value, name2) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) {
+    throw new Error(name2 + " must be a positive integer");
+  }
+  return value;
+}
+function parseReadArgs(args) {
+  if (args.file_path.trim().length === 0) throw new Error("file_path must be a non-empty string");
+  const offset = args.offset === void 0 ? 1 : parsePositiveInteger(args.offset, "offset");
+  const limit = args.limit === void 0 ? READ_LIMIT : parsePositiveInteger(args.limit, "limit");
+  if (limit > READ_LIMIT) throw new Error("limit must be less than or equal to " + READ_LIMIT);
+  return { filePath: args.file_path, offset, limit };
+}
+function createReadRemoteTool(fs) {
+  return defineTool({
+    name: "read_remote",
+    description: "Read a UTF-8 text file on a remote host over ssh and return line-numbered content.",
+    parameters: {
+      file_path: { type: "string", required: true, description: "Remote target and path in one: alias:path, e.g. wsl:~/x.md or myserver:/etc/hosts. Alias comes from your ssh config." },
+      offset: { type: "number", description: "1-based first line to return. Defaults to 1." },
+      limit: { type: "number", description: "Maximum number of lines to return. Defaults to " + READ_LIMIT + "." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          path: { type: "string", required: true },
+          offset: { type: "integer", required: true },
+          lines: {
+            type: "array",
+            required: true,
+            items: { type: "object", additionalProperties: false, properties: { number: { type: "integer", required: true }, text: { type: "string", required: true } } }
+          },
+          totalLines: { type: "integer", required: true }
+        }
+      },
+      render: (args, value) => {
+        const input = parseReadArgs(args);
+        const endLine = value.lines.at(-1)?.number ?? Math.max(0, value.offset - 1);
+        const truncatedByBytes = value.lines.length < input.limit && endLine < value.totalLines;
+        return [{ type: "text", text: formatReadOutput(value.path, { offset: value.offset, lines: value.lines, totalLines: value.totalLines, ...truncatedByBytes ? { truncatedByBytes: true } : {} }) }];
+      },
+      presentationMeta: (_args, value) => {
+        const lang = langFromPath(value.path);
+        return { path: value.path, offset: value.offset, lines: value.lines.map(({ number, text }) => ({ number, text })), totalLines: value.totalLines, ...lang === void 0 ? {} : { lang } };
+      }
+    },
+    isConcurrencySafe: () => true,
+    async execute(args, exec) {
+      const input = parseReadArgs(args);
+      if (exec.signal.aborted) throw new FsError4("cancelled", "FS_ABORTED");
+      const target = await fs.resolve(input.filePath);
+      const text = await fs.readText(target);
+      const window = buildWindow(text, { offset: input.offset, limit: input.limit, maxLineLength: READ_MAX_LINE_LENGTH, maxBytes: READ_MAX_BYTES }, target.displayPath);
+      return { path: target.displayPath, offset: input.offset, lines: window.lines, totalLines: window.totalLines };
+    },
+    presentResult(_args, result) {
+      if (result.isError) return void 0;
+      const meta = readMetaFromMeta(result.meta);
+      if (meta === void 0) return void 0;
+      const only = result.content.length === 1 ? result.content[0] : void 0;
+      const text = only?.type === "text" ? only.text : void 0;
+      if (text === void 0) return void 0;
+      const body = /^<path>[^\n]*<\/path>\n<type>file<\/type>\n<content>\n([\s\S]*)\n<\/content>$/u.exec(text)?.[1];
+      if (body === void 0) return void 0;
+      return { card: "read", path: meta.path, offset: meta.offset, lines: meta.lines, totalLines: meta.totalLines, ...meta.lang === void 0 ? {} : { lang: meta.lang }, content: [{ type: "text", text: body }] };
+    },
+    presentCall(args) {
+      const a = args;
+      const windowText = a.limit !== void 0 && a.limit > 0 ? " (" + (a.offset ?? 1) + " - " + ((a.offset ?? 1) + a.limit - 1) + ")" : a.offset !== void 0 ? " (from line " + a.offset + ")" : "";
+      return { card: "generic", title: "Read " + a.file_path + windowText, kind: "read", locations: [{ path: a.file_path, line: a.offset ?? 1 }] };
+    }
+  });
+}
+
+// src/write.ts
+import { defineTool as defineTool2 } from "@deepseek-ai/dsh-tools";
+import { FsError as FsError5 } from "@deepseek-ai/dsh-fs";
+function parseWriteArgs(args) {
+  if (args.file_path.trim().length === 0) throw new Error("file_path must be a non-empty string");
+  return { filePath: args.file_path, content: args.content };
+}
+function createWriteRemoteTool(fs) {
+  return defineTool2({
+    name: "write_remote",
+    description: "Create a new UTF-8 text file on a remote host over ssh. The target must NOT already exist — write_remote only creates new files, never overwrites.",
+    parameters: {
+      file_path: { type: "string", required: true, description: "Remote target and path in one: alias:path, e.g. wsl:~/x.md or myserver:/etc/hosts. Must not already exist." },
+      content: { type: "string", required: true, description: "Full UTF-8 text content to write." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          path: { type: "string", required: true },
+          operation: { type: "string", required: true, enum: ["create", "update"] },
+          before: { required: true, oneOf: [{ type: "string" }, { type: "null" }] },
+          after: { type: "string", required: true }
+        }
+      },
+      render: (_args, value) => [{ type: "text", text: formatWriteOutput(value.path, value.operation) }],
+      presentationMeta: (args, value) => ({ diffs: value.before === null ? [] : computeHunkDiffs(args.file_path, value.before, value.after).map(({ path, oldText, newText }) => ({ path, oldText, newText })) })
+    },
+    isConcurrencySafe: () => true,
+    async execute(args, exec) {
+      const input = parseWriteArgs(args);
+      if (exec.signal.aborted) throw new FsError5("cancelled", "FS_ABORTED");
+      const target = await fs.resolve(input.filePath);
+      const outcome = await fs.writeText(target, input.content, { kind: "createIfAbsent" });
+      return { path: target.displayPath, operation: outcome.operation, before: outcome.before, after: outcome.after };
+    },
+    presentCall(args) {
+      const a = args;
+      return { card: "diff", title: "Write " + a.file_path, diffs: [{ path: a.file_path, oldText: null, newText: a.content }], locations: [{ path: a.file_path }] };
+    },
+    presentResult(args, result) {
+      if (result.isError) return void 0;
+      const a = args;
+      const diffs = diffsFromMeta(result.meta) ?? [{ path: a.file_path, oldText: null, newText: a.content }];
+      return { card: "diff", title: "Write " + a.file_path, diffs };
+    }
+  });
+}
+
+// src/edit.ts
+import { defineTool as defineTool3 } from "@deepseek-ai/dsh-tools";
+import { FsError as FsError6 } from "@deepseek-ai/dsh-fs";
+function parseEditArgs(args) {
+  if (args.file_path.trim().length === 0) throw new Error("file_path must be a non-empty string");
+  if (args.old_string.length === 0) throw new Error("old_string must be a non-empty string");
+  if (args.old_string === args.new_string) throw new Error("old_string and new_string must differ");
+  return { filePath: args.file_path, oldString: args.old_string, newString: args.new_string, replaceAll: args.replace_all ?? false };
+}
+function createEditRemoteTool(fs) {
+  return defineTool3({
+    name: "edit_remote",
+    description: "Edit an existing UTF-8 text file on a remote host over ssh by replacing literal text.",
+    parameters: {
+      file_path: { type: "string", required: true, description: "Remote target and path in one: alias:path, e.g. wsl:~/x.md or myserver:/etc/hosts." },
+      old_string: { type: "string", required: true, description: "Literal text to replace. Must match exactly." },
+      new_string: { type: "string", required: true, description: "Literal replacement text. Use an empty string to delete the match." },
+      replace_all: { type: "boolean", description: "Replace all matches. Defaults to false; when false, old_string must appear exactly once." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          path: { type: "string", required: true },
+          before: { type: "string", required: true },
+          after: { type: "string", required: true }
+        }
+      },
+      render: (args, value) => [{ type: "text", text: formatEditOutput(value.path, args.replace_all ?? false) }],
+      presentationMeta: (args, value) => ({ diffs: computeHunkDiffs(args.file_path, value.before, value.after).map(({ path, oldText, newText }) => ({ path, oldText, newText })) })
+    },
+    isConcurrencySafe: () => false,
+    async execute(args, exec) {
+      const input = parseEditArgs(args);
+      if (exec.signal.aborted) throw new FsError6("cancelled", "FS_ABORTED");
+      const target = await fs.resolve(input.filePath);
+      const outcome = await fs.editText(target, { oldString: input.oldString, newString: input.newString, replaceAll: input.replaceAll });
+      return { path: target.displayPath, before: outcome.before, after: outcome.after };
+    },
+    presentCall(args) {
+      const a = args;
+      return { card: "diff", title: "Edit " + a.file_path, diffs: [{ path: a.file_path, oldText: a.old_string || null, newText: a.new_string }], locations: [{ path: a.file_path }] };
+    },
+    presentResult(args, result) {
+      if (result.isError) return void 0;
+      const a = args;
+      const diffs = diffsFromMeta(result.meta);
+      if (diffs === void 0) return void 0;
+      return { card: "diff", title: "Edit " + a.file_path, diffs };
+    }
+  });
+}
+
+// src/index.ts
+var name = "dsh-remote-file-system";
+var inject = ["tools", "systemPrompt"];
+function apply(ctx, config = {}) {
+  if (config.enabled === false) return;
+  const fs = new RemoteFileSystem();
+  ctx.systemPrompt.section({
+    name: "tool:read_remote",
+    order: ctx.systemPrompt.getSectionOrder("TOOL_READ"),
+    text: "Use read_remote (not shell commands) to inspect UTF-8 text files on remote hosts over ssh. file_path carries the target as alias:path (e.g. wsl:~/x.md). Results include line numbers; use offset and limit to continue reading large files."
+  });
+  ctx.systemPrompt.section({
+    name: "tool:write_remote",
+    order: ctx.systemPrompt.getSectionOrder("TOOL_WRITE"),
+    text: "Use write_remote to create a NEW UTF-8 text file on a remote host. It only creates — the target must not already exist, and it never overwrites."
+  });
+  ctx.systemPrompt.section({
+    name: "tool:edit_remote",
+    order: ctx.systemPrompt.getSectionOrder("TOOL_EDIT"),
+    text: "Use edit_remote for targeted literal changes to an existing remote text file. It replaces literal old_string with new_string; by default old_string must appear exactly once."
+  });
+  ctx.tools.register(createReadRemoteTool(fs));
+  ctx.tools.register(createWriteRemoteTool(fs));
+  ctx.tools.register(createEditRemoteTool(fs));
+}
+export {
+  apply,
+  inject,
+  name
+};
+//# sourceMappingURL=index.js.map