farming-code 2.2.29 → 2.2.32

package/backend/acp/patch-decisions.cjs

@@ -0,0 +1,182 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var patch_decisions_exports = {};
+__export(patch_decisions_exports, {
+  AcpPatchDecisionError: () => AcpPatchDecisionError,
+  logicalPatchPath: () => logicalPatchPath,
+  patchBlock: () => patchBlock,
+  rejectPatch: () => rejectPatch
+});
+module.exports = __toCommonJS(patch_decisions_exports);
+var import_client_services = require("./client-services.cjs");
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const fsp = fs.promises;
+class AcpPatchDecisionError extends Error {
+  statusCode;
+  constructor(message, statusCode = 409) {
+    super(message);
+    this.name = "AcpPatchDecisionError";
+    this.statusCode = statusCode;
+  }
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function fileSystemErrorCode(error) {
+  return error && typeof error === "object" && "code" in error ? error.code : void 0;
+}
+function inside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function logicalPatchPath(root, requestedPath) {
+  const workspace = path.resolve(root);
+  let realWorkspace = workspace;
+  try {
+    realWorkspace = fs.realpathSync.native(workspace);
+  } catch {
+  }
+  const value = String(requestedPath || "").trim();
+  if (!value || value.includes("\0")) throw new AcpPatchDecisionError("ACP patch path is invalid", 400);
+  const target = path.resolve(path.isAbsolute(value) ? value : path.join(workspace, value));
+  if (!inside(workspace, target) && !inside(realWorkspace, target)) {
+    throw new AcpPatchDecisionError("ACP patch is outside the Agent workspace", 403);
+  }
+  return target;
+}
+function relativeWorkspacePath(root, target) {
+  const workspace = path.resolve(root);
+  let realWorkspace = workspace;
+  try {
+    realWorkspace = fs.realpathSync.native(workspace);
+  } catch {
+  }
+  const base = inside(workspace, target) ? workspace : realWorkspace;
+  return path.relative(base, target);
+}
+function matchingDiffBlocks(entry, root, requestedPath) {
+  const requested = logicalPatchPath(root, requestedPath);
+  const content = recordValue(entry).content;
+  return (Array.isArray(content) ? content : []).filter(
+    (block) => {
+      if (!block || typeof block !== "object" || Array.isArray(block)) return false;
+      const blockRecord = block;
+      if (blockRecord.type !== "diff" || typeof blockRecord.path !== "string") return false;
+      try {
+        return logicalPatchPath(root, blockRecord.path) === requested;
+      } catch {
+        return false;
+      }
+    }
+  );
+}
+function patchBlock(entry, root, requestedPath) {
+  const matches = matchingDiffBlocks(entry, root, requestedPath);
+  if (matches.length === 0) throw new AcpPatchDecisionError("ACP patch file was not found", 404);
+  if (matches.length > 1) throw new AcpPatchDecisionError("ACP patch file has multiple changes; open Review to resolve them", 409);
+  return matches[0];
+}
+function patchKind(block) {
+  return String(recordValue(block._meta).kind || "").trim().toLowerCase();
+}
+async function existingTarget(root, requestedPath) {
+  const logical = logicalPatchPath(root, requestedPath);
+  let stat;
+  try {
+    stat = await fsp.lstat(logical);
+  } catch (error) {
+    if (fileSystemErrorCode(error) === "ENOENT") {
+      return { exists: false, logical, target: null, stat: null };
+    }
+    throw error;
+  }
+  if (stat.isSymbolicLink()) throw new AcpPatchDecisionError("ACP patch decision will not modify a symbolic link", 409);
+  if (!stat.isFile()) throw new AcpPatchDecisionError("ACP patch target is not a regular file", 409);
+  const target = await (0, import_client_services.resolveWorkspacePath)({ cwd: root }, logical);
+  return { exists: true, logical, target, stat };
+}
+async function missingTarget(root, requestedPath) {
+  const logical = logicalPatchPath(root, requestedPath);
+  const target = await (0, import_client_services.resolveWorkspacePath)({ cwd: root }, logical, { allowMissing: true });
+  return { logical, target };
+}
+async function atomicWrite(target, content, mode = 438) {
+  const temporary = path.join(
+    path.dirname(target),
+    `.${path.basename(target)}.farming-acp-revert-${process.pid}-${crypto.randomUUID()}.tmp`
+  );
+  try {
+    await fsp.writeFile(temporary, content, { mode });
+    await fsp.rename(temporary, target);
+  } catch (error) {
+    await fsp.rm(temporary, { force: true }).catch(() => {
+    });
+    throw error;
+  }
+}
+async function rejectPatch({
+  entry,
+  root,
+  requestedPath
+}) {
+  const block = patchBlock(entry, root, requestedPath);
+  const oldText = block.oldText == null ? "" : String(block.oldText);
+  const newText = block.newText == null ? "" : String(block.newText);
+  const kind = patchKind(block);
+  const added = block.oldText == null || ["add", "added", "create", "created"].includes(kind);
+  const deleted = ["delete", "deleted", "remove", "removed"].includes(kind);
+  const current = await existingTarget(root, requestedPath);
+  if (deleted) {
+    if (current.exists) {
+      const currentText2 = await fsp.readFile(current.target, "utf8");
+      if (currentText2 === oldText) {
+        return { action: "reverted", path: relativeWorkspacePath(root, current.logical) };
+      }
+      throw new AcpPatchDecisionError("File changed after this ACP patch; it was not reverted", 409);
+    }
+    const target = await missingTarget(root, requestedPath);
+    await atomicWrite(target.target, oldText);
+    return { action: "reverted", path: relativeWorkspacePath(root, target.logical) };
+  }
+  if (!current.exists) {
+    if (added) return { action: "reverted", path: relativeWorkspacePath(root, current.logical) };
+    throw new AcpPatchDecisionError("File changed after this ACP patch; it was not reverted", 409);
+  }
+  const currentText = await fsp.readFile(current.target, "utf8");
+  if (!added && currentText === oldText) {
+    return { action: "reverted", path: relativeWorkspacePath(root, current.logical) };
+  }
+  if (currentText !== newText) throw new AcpPatchDecisionError("File changed after this ACP patch; it was not reverted", 409);
+  if (added) {
+    await fsp.rm(current.target);
+  } else {
+    await atomicWrite(current.target, oldText, current.stat.mode);
+  }
+  return { action: "reverted", path: relativeWorkspacePath(root, current.logical) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AcpPatchDecisionError,
+  logicalPatchPath,
+  patchBlock,
+  rejectPatch
+});

package/backend/acp/permission-security.cjs

@@ -0,0 +1,131 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var permission_security_exports = {};
+__export(permission_security_exports, {
+  permissionSecurityWarnings: () => permissionSecurityWarnings,
+  scanUnicode: () => scanUnicode
+});
+module.exports = __toCommonJS(permission_security_exports);
+const { domainToUnicode } = require("url");
+const BIDI_NAMES = /* @__PURE__ */ new Map([
+  [1564, "arabic letter mark"],
+  [8206, "left-to-right mark"],
+  [8207, "right-to-left mark"],
+  [8234, "left-to-right embedding"],
+  [8235, "right-to-left embedding"],
+  [8236, "pop directional formatting"],
+  [8237, "left-to-right override"],
+  [8238, "right-to-left override"],
+  [8294, "left-to-right isolate"],
+  [8295, "right-to-left isolate"],
+  [8296, "first strong isolate"],
+  [8297, "pop directional isolate"]
+]);
+const INVISIBLE_NAMES = /* @__PURE__ */ new Map([
+  [160, "no-break space"],
+  [173, "soft hyphen"],
+  [6158, "mongolian vowel separator"],
+  [8203, "zero-width space"],
+  [8204, "zero-width non-joiner"],
+  [8205, "zero-width joiner"],
+  [8288, "word joiner"],
+  [12288, "ideographic space"],
+  [65279, "zero-width no-break space"]
+]);
+function codePoint(character) {
+  const point = character.codePointAt(0);
+  if (point === void 0) throw new Error("Cannot classify an empty Unicode character");
+  return point;
+}
+function codePointLabel(character) {
+  return `U+${codePoint(character).toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function scriptName(character) {
+  const scripts = [
+    ["Cyrillic", new RegExp("\\p{Script=Cyrillic}", "u")],
+    ["Greek", new RegExp("\\p{Script=Greek}", "u")],
+    ["Arabic", new RegExp("\\p{Script=Arabic}", "u")],
+    ["Hebrew", new RegExp("\\p{Script=Hebrew}", "u")],
+    ["Han", new RegExp("\\p{Script=Han}", "u")],
+    ["Hiragana", new RegExp("\\p{Script=Hiragana}", "u")],
+    ["Katakana", new RegExp("\\p{Script=Katakana}", "u")],
+    ["Latin", new RegExp("\\p{Script=Latin}", "u")]
+  ];
+  return scripts.find(([, matcher]) => matcher instanceof RegExp && matcher.test(character))?.[0] || "Unicode";
+}
+function classifyCharacter(character) {
+  const point = codePoint(character);
+  if (BIDI_NAMES.has(point)) {
+    return {
+      character: "",
+      codePoint: codePointLabel(character),
+      kind: "bidi-control",
+      description: BIDI_NAMES.get(point) || "bidirectional control"
+    };
+  }
+  if (INVISIBLE_NAMES.has(point) || point >= 8289 && point <= 8292 || point >= 8192 && point <= 8202 || [5760, 8239, 8287].includes(point) || new RegExp("\\p{Control}|\\p{Format}", "u").test(character)) {
+    return {
+      character: "",
+      codePoint: codePointLabel(character),
+      kind: "invisible",
+      description: INVISIBLE_NAMES.get(point) || "invisible or formatting character"
+    };
+  }
+  return {
+    character,
+    codePoint: codePointLabel(character),
+    kind: "confusable",
+    description: `${scriptName(character)} character`
+  };
+}
+function scanUnicode(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const findings = [];
+  for (const character of String(value || "")) {
+    if (codePoint(character) <= 127 || seen.has(character)) continue;
+    seen.add(character);
+    findings.push(classifyCharacter(character));
+  }
+  return findings;
+}
+function permissionSecurityWarnings(request) {
+  const meta = { ...request?._meta || {}, ...request?.toolCall?._meta || {} };
+  const sandbox = meta.sandbox_authorization;
+  if (!sandbox || typeof sandbox !== "object" || Array.isArray(sandbox)) return [];
+  const sandboxRecord = sandbox;
+  const warnings = [];
+  const add = (targetType, value, displayValue = value) => {
+    const characters = scanUnicode(displayValue);
+    if (characters.length > 0) warnings.push({ targetType, value, displayValue, characters });
+  };
+  for (const host of Array.isArray(sandboxRecord.network_hosts) ? sandboxRecord.network_hosts : []) {
+    const value = String(host || "");
+    add("host", value, domainToUnicode(value) || value);
+  }
+  for (const targetPath of Array.isArray(sandboxRecord.write_paths) ? sandboxRecord.write_paths : []) {
+    add("path", String(targetPath || ""));
+  }
+  return warnings;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  permissionSecurityWarnings,
+  scanUnicode
+});

package/backend/{acp-checkpoint-store.js → acp-checkpoint-store.cjs}

@@ -1,17 +1,58 @@
-const crypto = require('crypto');
-const fs = require('fs/promises');
-const path = require('path');
-const { promisify } = require('util');
-const zlib = require('zlib');
-const storageLayout = require('./storage-layout');
-
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var acp_checkpoint_store_exports = {};
+__export(acp_checkpoint_store_exports, {
+  AcpCheckpointStore: () => AcpCheckpointStore,
+  CHECKPOINT_VERSION: () => CHECKPOINT_VERSION,
+  checkpointKey: () => checkpointKey,
+  normalizeIdentity: () => normalizeIdentity
+});
+module.exports = __toCommonJS(acp_checkpoint_store_exports);
+var storageLayout = __toESM(require("./storage-layout.cjs"));
+const crypto = require("crypto");
+const fs = require("fs/promises");
+const path = require("path");
+const { promisify } = require("util");
+const zlib = require("zlib");
 const gzip = promisify(zlib.gzip);
 const gunzip = promisify(zlib.gunzip);
 const CHECKPOINT_VERSION = 1;
 const DEFAULT_WRITE_DELAY_MS = 250;
-
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errorCode(error) {
+  return error instanceof Error && "code" in error ? String(error.code) : "";
+}
 async function durableWrite(file, data) {
-  const handle = await fs.open(file, 'w');
+  const handle = await fs.open(file, "w");
   try {
     await handle.writeFile(data);
     await handle.sync();
@@ -19,57 +60,52 @@ async function durableWrite(file, data) {
     await handle.close();
   }
 }
-
 async function syncDirectory(directory) {
-  const handle = await fs.open(directory, 'r');
+  const handle = await fs.open(directory, "r");
   try {
     await handle.sync();
   } finally {
     await handle.close();
   }
 }
-
 function normalizeIdentity(value = {}) {
+  const candidate = isObject(value) ? value : {};
   return {
-    provider: String(value.provider || '').trim().toLowerCase(),
-    providerHomeId: String(value.providerHomeId || 'default').trim() || 'default',
-    sessionId: String(value.sessionId || '').trim(),
-    cwd: path.resolve(String(value.cwd || process.cwd())),
+    provider: String(candidate.provider || "").trim().toLowerCase(),
+    providerHomeId: String(candidate.providerHomeId || "default").trim() || "default",
+    sessionId: String(candidate.sessionId || "").trim(),
+    cwd: path.resolve(String(candidate.cwd || process.cwd()))
   };
 }
-
 function checkpointKey(identity) {
-  return crypto.createHash('sha256')
-    .update(JSON.stringify(normalizeIdentity(identity)))
-    .digest('hex');
+  return crypto.createHash("sha256").update(JSON.stringify(normalizeIdentity(identity))).digest("hex");
 }
-
 function sameIdentity(left, right) {
   return JSON.stringify(normalizeIdentity(left)) === JSON.stringify(normalizeIdentity(right));
 }
-
 class AcpCheckpointStore {
+  dir;
+  writeDelayMs;
+  pending;
+  writeChains;
   constructor(configDir, options = {}) {
     this.dir = storageLayout.acpCheckpointsDir(configDir);
-    this.writeDelayMs = Number.isFinite(Number(options.writeDelayMs))
-      ? Math.max(0, Math.floor(Number(options.writeDelayMs)))
-      : DEFAULT_WRITE_DELAY_MS;
-    this.pending = new Map();
-    this.writeChains = new Map();
+    this.writeDelayMs = Number.isFinite(Number(options.writeDelayMs)) ? Math.max(0, Math.floor(Number(options.writeDelayMs))) : DEFAULT_WRITE_DELAY_MS;
+    this.pending = /* @__PURE__ */ new Map();
+    this.writeChains = /* @__PURE__ */ new Map();
   }
-
   paths(identity) {
     const key = checkpointKey(identity);
     return {
       key,
       checkpoint: path.join(this.dir, `${key}.json.gz`),
-      dirty: path.join(this.dir, `${key}.dirty`),
+      dirty: path.join(this.dir, `${key}.dirty`)
     };
   }
-
   enqueue(key, operation) {
     const previous = this.writeChains.get(key) || Promise.resolve();
-    const next = previous.catch(() => {}).then(operation);
+    const next = previous.catch(() => {
+    }).then(operation);
     this.writeChains.set(key, next);
     void next.then(() => {
       if (this.writeChains.get(key) === next) this.writeChains.delete(key);
@@ -78,34 +114,29 @@ class AcpCheckpointStore {
     });
     return next;
   }
-
   async load(identity, options = {}) {
     const normalized = normalizeIdentity(identity);
     if (!normalized.provider || !normalized.sessionId) return null;
     const files = this.paths(normalized);
     const inFlight = this.writeChains.get(files.key);
-    if (inFlight) await inFlight.catch(() => {});
+    if (inFlight) await inFlight.catch(() => {
+    });
     try {
       const [compressed, dirty] = await Promise.all([
         fs.readFile(files.checkpoint),
-        fs.access(files.dirty).then(() => true).catch(() => false),
+        fs.access(files.dirty).then(() => true).catch(() => false)
       ]);
-      const payload = JSON.parse((await gunzip(compressed)).toString('utf8'));
-      if (
-        payload?.version !== CHECKPOINT_VERSION
-        || !sameIdentity(payload.identity, normalized)
-        || !payload.state
-      ) return null;
+      const payload = JSON.parse((await gunzip(compressed)).toString("utf8"));
+      if (!isObject(payload) || payload.version !== CHECKPOINT_VERSION || !sameIdentity(payload.identity, normalized) || !payload.state) return null;
       if (dirty && options.allowDirty !== true) return null;
       return { state: payload.state, exact: !dirty, savedAt: Number(payload.savedAt || 0) };
     } catch (error) {
-      if (error?.code !== 'ENOENT') {
-        console.warn('Failed to read ACP checkpoint:', error && (error.message || error));
+      if (errorCode(error) !== "ENOENT") {
+        console.warn("Failed to read ACP checkpoint:", error instanceof Error ? error.message : error);
       }
       return null;
     }
   }
-
   async markDirty(identity) {
     const normalized = normalizeIdentity(identity);
     if (!normalized.provider || !normalized.sessionId) return;
@@ -115,11 +146,11 @@ class AcpCheckpointStore {
     this.pending.delete(files.key);
     return this.enqueue(files.key, async () => {
       await fs.mkdir(this.dir, { recursive: true });
-      await durableWrite(files.dirty, `${Date.now()}\n`);
+      await durableWrite(files.dirty, `${Date.now()}
+`);
       await syncDirectory(this.dir);
     });
   }
-
   schedule(identity, state, options = {}) {
     const normalized = normalizeIdentity(identity);
     if (!normalized.provider || !normalized.sessionId || !state) return;
@@ -130,7 +161,7 @@ class AcpCheckpointStore {
       identity: normalized,
       state,
       exact: options.exact === true,
-      timer: null,
+      timer: null
     };
     pending.timer = setTimeout(() => {
       this.pending.delete(files.key);
@@ -139,7 +170,6 @@ class AcpCheckpointStore {
     pending.timer.unref?.();
     this.pending.set(files.key, pending);
   }
-
   async write(identity, state, options = {}) {
     const normalized = normalizeIdentity(identity);
     if (!normalized.provider || !normalized.sessionId || !state) return;
@@ -152,12 +182,13 @@ class AcpCheckpointStore {
         version: CHECKPOINT_VERSION,
         savedAt: Date.now(),
         identity: normalized,
-        state: state.exportCheckpoint(),
+        state: state.exportCheckpoint()
       };
       const compressed = await gzip(Buffer.from(JSON.stringify(payload)), { level: zlib.constants.Z_BEST_SPEED });
       await fs.mkdir(this.dir, { recursive: true });
       if (options.exact !== true) {
-        await durableWrite(files.dirty, `${Date.now()}\n`);
+        await durableWrite(files.dirty, `${Date.now()}
+`);
         await syncDirectory(this.dir);
       }
       const temporary = `${files.checkpoint}.${process.pid}.${Date.now()}.tmp`;
@@ -166,7 +197,8 @@ class AcpCheckpointStore {
         await fs.rename(temporary, files.checkpoint);
         await syncDirectory(this.dir);
       } finally {
-        await fs.rm(temporary, { force: true }).catch(() => {});
+        await fs.rm(temporary, { force: true }).catch(() => {
+        });
       }
       if (options.exact === true) {
         await fs.rm(files.dirty, { force: true });
@@ -174,25 +206,24 @@ class AcpCheckpointStore {
       }
     });
   }
-
   async flush() {
     const pending = [...this.pending.values()];
     this.pending.clear();
-    pending.forEach(item => {
+    pending.forEach((item) => {
       if (item.timer) clearTimeout(item.timer);
     });
-    await Promise.all(pending.map(item => this.write(item.identity, item.state, { exact: item.exact })));
-    await Promise.all([...this.writeChains.values()].map(write => write.catch(() => {})));
+    await Promise.all(pending.map((item) => this.write(item.identity, item.state, { exact: item.exact })));
+    await Promise.all([...this.writeChains.values()].map((write) => write.catch(() => {
+    })));
   }
-
   async dispose() {
     await this.flush();
   }
 }
-
-module.exports = {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   AcpCheckpointStore,
   CHECKPOINT_VERSION,
   checkpointKey,
-  normalizeIdentity,
-};
+  normalizeIdentity
+});