@theokit/sdk-tools 0.20.1 → 0.21.0

package/dist/index.cjs

@@ -4,105 +4,17 @@ var promises = require('fs/promises');
 var path = require('path');
 var sdk = require('@theokit/sdk');
 var zod = require('zod');
-var fs = require('fs');
 var pathSafety = require('@theokit/sdk/path-safety');
 var persistence = require('@theokit/sdk/persistence');
 var filesystem = require('@theokit/sdk/filesystem');
 var child_process = require('child_process');
+var fs = require('fs');
 var sandbox = require('@theokit/sdk/sandbox');
 var interactive = require('@theokit/sdk/interactive');
 var promises$1 = require('dns/promises');
 var net = require('net');
 
 // src/apply-patch.ts
-var PathTraversalError = class extends sdk.ConfigurationError {
-  name = "PathTraversalError";
-  constructor(input, resolvedPath) {
-    super(`Path traversal attempt: ${input} \u2192 ${resolvedPath}`, {
-      code: "path_traversal"
-    });
-  }
-};
-var ForbiddenPathError = class extends sdk.ConfigurationError {
-  name = "ForbiddenPathError";
-  constructor(path) {
-    super(
-      `Path '${path}' is in the sensitive-file blocklist (.env, .git/, node_modules/, .theo/, lock files)`,
-      {
-        code: "forbidden_path"
-      }
-    );
-  }
-};
-function safePathJoin(base, ...parts) {
-  if (base === "") {
-    throw new Error("safePathJoin: base must be non-empty");
-  }
-  const baseResolved = path.resolve(base);
-  const target = path.resolve(base, ...parts);
-  if (target !== baseResolved && !target.startsWith(baseResolved + path.sep)) {
-    throw new PathTraversalError(parts.join("/"), target);
-  }
-  return target;
-}
-function assertNoSymlinkEscape(path$1, base) {
-  let baseResolved;
-  try {
-    baseResolved = fs.realpathSync(base);
-  } catch {
-    baseResolved = path.resolve(base);
-  }
-  const resolved = realpathOfDeepestExisting(path$1);
-  if (resolved === void 0) return;
-  if (resolved !== baseResolved && !resolved.startsWith(baseResolved + path.sep)) {
-    throw new PathTraversalError(`symlink ${path$1}`, resolved);
-  }
-}
-function realpathOfDeepestExisting(path$1) {
-  try {
-    return fs.realpathSync(path$1);
-  } catch {
-  }
-  try {
-    const stat3 = fs.lstatSync(path$1);
-    if (stat3.isSymbolicLink()) {
-      const target = fs.readlinkSync(path$1);
-      const parentReal = realpathOfDeepestExisting(path.dirname(path$1));
-      const parentBase = parentReal ?? path.dirname(path$1);
-      return path.resolve(parentBase, target);
-    }
-  } catch {
-  }
-  let cursor = path.dirname(path$1);
-  let suffix = path$1.slice(cursor.length);
-  while (cursor !== path.dirname(cursor)) {
-    try {
-      const real = fs.realpathSync(cursor);
-      return path.resolve(real, `.${suffix}`);
-    } catch {
-      suffix = path$1.slice(path.dirname(cursor).length);
-      cursor = path.dirname(cursor);
-    }
-  }
-  return void 0;
-}
-var LOCK_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"]);
-function isForbiddenPath(input) {
-  const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
-  if (normalized.length === 0) return false;
-  const segments = normalized.split("/").filter((s) => s.length > 0);
-  if (segments.length === 0) return false;
-  const first = segments[0];
-  if (first === ".env.example") return false;
-  if (first === ".env") return true;
-  if (/^\.env\./.test(first)) return true;
-  if (first === ".git") return true;
-  if (first === "node_modules") return true;
-  if (first === ".theo") return true;
-  const basename = segments[segments.length - 1];
-  if (LOCK_FILES.has(basename)) return true;
-  return false;
-}
 
 // src/internal/v4a-patch.ts
 var BEGIN = "*** Begin Patch";
@@ -446,15 +358,15 @@ function isForbiddenRel(rel) {
 function v4aScope(projectRoot, file) {
   let abs;
   try {
-    abs = safePathJoin(projectRoot, file);
-    assertNoSymlinkEscape(abs, projectRoot);
+    abs = pathSafety.safePathJoin(projectRoot, file);
+    pathSafety.assertNoSymlinkEscape(abs, projectRoot);
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return { error: JSON.stringify({ ok: false, error: "path_traversal", path: file }) };
     }
     throw err;
   }
-  if (isForbiddenPath(file) || isForbiddenRel(path.relative(projectRoot, abs))) {
+  if (pathSafety.isForbiddenPath(file) || isForbiddenRel(path.relative(projectRoot, abs))) {
     return { error: JSON.stringify({ ok: false, error: "forbidden_path", path: file }) };
   }
   return { abs };
@@ -665,7 +577,7 @@ async function editViaBackend(filesystem$1, ctx, path, old_string, new_string) {
   return JSON.stringify({ ok: true, replacements: 1 });
 }
 async function editViaLocal(projectRoot, path, old_string, new_string) {
-  const absolutePath = safePathJoin(projectRoot, path);
+  const absolutePath = pathSafety.safePathJoin(projectRoot, path);
   let content;
   try {
     content = await promises.readFile(absolutePath, "utf-8");
@@ -683,14 +595,14 @@ async function editViaLocal(projectRoot, path, old_string, new_string) {
   return JSON.stringify({ ok: true, replacements: 1 });
 }
 function editScopeError(path, projectRoot) {
-  if (isForbiddenPath(path)) {
+  if (pathSafety.isForbiddenPath(path)) {
     return JSON.stringify({ ok: false, error: "forbidden_path", path });
   }
   try {
-    assertNoSymlinkEscape(safePathJoin(projectRoot, path), projectRoot);
+    pathSafety.assertNoSymlinkEscape(pathSafety.safePathJoin(projectRoot, path), projectRoot);
     return null;
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return JSON.stringify({ ok: false, error: "path_traversal", path });
     }
     throw err;
@@ -776,11 +688,11 @@ function formatError(message, code) {
 function checkPathScope(path, projectRoot) {
   if (path === void 0 || path === "") return null;
   try {
-    const abs = safePathJoin(projectRoot, path);
-    assertNoSymlinkEscape(abs, projectRoot);
+    const abs = pathSafety.safePathJoin(projectRoot, path);
+    pathSafety.assertNoSymlinkEscape(abs, projectRoot);
     return null;
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return JSON.stringify({ ok: false, error: "path_traversal", path });
     }
     throw err;
@@ -800,25 +712,25 @@ function createSettleGate(timer) {
     }
   };
 }
-function armTimeoutKill(child, timeoutMs, onTimeout, resolve2) {
+function armTimeoutKill(child, timeoutMs, onTimeout, resolve) {
   const timer = setTimeout(() => {
     gate.fire(() => {
       try {
         process.kill(-(child.pid ?? 0), "SIGKILL");
       } catch {
       }
-      resolve2(onTimeout());
+      resolve(onTimeout());
     });
   }, timeoutMs);
   const gate = createSettleGate(timer);
   return gate;
 }
-function attachChildSettlers(child, gate, onClose, onError, resolve2) {
+function attachChildSettlers(child, gate, onClose, onError, resolve) {
   child.on("close", (code) => {
-    gate.fire(() => resolve2(onClose(code)));
+    gate.fire(() => resolve(onClose(code)));
   });
   child.on("error", (err) => {
-    gate.fire(() => resolve2(onError(err)));
+    gate.fire(() => resolve(onError(err)));
   });
 }
 
@@ -885,7 +797,7 @@ function formatGitResult(result, timeoutMs) {
   return JSON.stringify({ ok: true, diff: result.stdout, truncated: result.truncated });
 }
 function runGitProcess(cwd, args, timeoutMs, maxStdoutBytes) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const child = child_process.spawn("git", args, { cwd, detached: true, stdio: ["ignore", "pipe", "pipe"] });
     const stdoutChunks = [];
     const stderrChunks = [];
@@ -895,7 +807,7 @@ function runGitProcess(cwd, args, timeoutMs, maxStdoutBytes) {
       child,
       timeoutMs,
       () => ({ kind: "timeout" }),
-      resolve2
+      resolve
     );
     child.stdout.on("data", (chunk) => {
       if (gate.settled()) return;
@@ -925,7 +837,7 @@ function runGitProcess(cwd, args, timeoutMs, maxStdoutBytes) {
         return code === 0 ? { kind: "ok", stdout, truncated } : { kind: "error", stderr };
       },
       (err) => ({ kind: "error", stderr: err.message }),
-      resolve2
+      resolve
     );
   });
 }
@@ -951,7 +863,7 @@ function createGlobTool(opts) {
         await walkDirBackend(backend, searchRel, searchRel, regex, found, 0);
         return JSON.stringify({ ok: true, files: found.sort(), count: found.length });
       }
-      const searchRoot = cwd ? safePathJoin(projectRoot, cwd) : projectRoot;
+      const searchRoot = cwd ? pathSafety.safePathJoin(projectRoot, cwd) : projectRoot;
       const files = [];
       await walkDir(searchRoot, searchRoot, regex, files);
       const relativePaths = files.map((f) => path.relative(projectRoot, f)).sort();
@@ -962,10 +874,10 @@ function createGlobTool(opts) {
 function globScopeError(cwd, projectRoot) {
   if (!cwd) return null;
   try {
-    assertNoSymlinkEscape(safePathJoin(projectRoot, cwd), projectRoot);
+    pathSafety.assertNoSymlinkEscape(pathSafety.safePathJoin(projectRoot, cwd), projectRoot);
     return null;
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return JSON.stringify({ ok: false, error: "path_traversal", path: cwd });
     }
     throw err;
@@ -1605,7 +1517,7 @@ function createListDirTool(opts) {
     }),
     handler: async ({ path }, ctx) => {
       const relative3 = path === "" || path === "." ? "." : path;
-      if (relative3 !== "." && isForbiddenPath(relative3)) {
+      if (relative3 !== "." && pathSafety.isForbiddenPath(relative3)) {
         return JSON.stringify({ ok: false, error: "forbidden_path", path });
       }
       if (filesystem$1) {
@@ -1653,11 +1565,11 @@ async function listViaBackend(backend, relative3, originalPath, max) {
 }
 function resolveDirBoundary(relative3, projectRoot, originalPath) {
   try {
-    const absolutePath = relative3 === "." ? projectRoot : safePathJoin(projectRoot, relative3);
-    assertNoSymlinkEscape(absolutePath, projectRoot);
+    const absolutePath = relative3 === "." ? projectRoot : pathSafety.safePathJoin(projectRoot, relative3);
+    pathSafety.assertNoSymlinkEscape(absolutePath, projectRoot);
     return { absolutePath };
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return { error: JSON.stringify({ ok: false, error: "path_traversal", path: originalPath }) };
     }
     throw err;
@@ -1819,7 +1731,7 @@ function isForbiddenAtAnyDepth(path) {
   });
 }
 function forbiddenReadError(path$1, allowAbsolute) {
-  if (isForbiddenPath(path$1)) {
+  if (pathSafety.isForbiddenPath(path$1)) {
     return JSON.stringify({ ok: false, error: "forbidden_path", path: path$1 });
   }
   if (allowAbsolute && path.isAbsolute(path$1) && isForbiddenAtAnyDepth(path$1)) {
@@ -1906,11 +1818,11 @@ function resolveBoundary(path$1, projectRoot, allowAbsolute) {
     return { absolutePath: path$1 };
   }
   try {
-    const absolutePath = safePathJoin(projectRoot, path$1);
-    assertNoSymlinkEscape(absolutePath, projectRoot);
+    const absolutePath = pathSafety.safePathJoin(projectRoot, path$1);
+    pathSafety.assertNoSymlinkEscape(absolutePath, projectRoot);
     return { absolutePath };
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return { error: JSON.stringify({ ok: false, error: "path_traversal", path: path$1 }) };
     }
     throw err;
@@ -2032,7 +1944,7 @@ function createRunVitestTool(opts) {
   });
 }
 function validateVitestScope(path, projectRoot) {
-  if (path !== void 0 && path !== "" && isForbiddenPath(path)) {
+  if (path !== void 0 && path !== "" && pathSafety.isForbiddenPath(path)) {
     return JSON.stringify({ ok: false, error: "forbidden_path", path });
   }
   return checkPathScope(path, projectRoot);
@@ -2078,7 +1990,7 @@ function appendCapped(chunks, chunk, current, cap) {
   return current + chunk.length;
 }
 function runProcess(cwd, command, args, timeoutMs, maxStdoutBytes) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const child = child_process.spawn(command, args, {
       cwd,
       detached: true,
@@ -2091,7 +2003,7 @@ function runProcess(cwd, command, args, timeoutMs, maxStdoutBytes) {
       child,
       timeoutMs,
       () => ({ kind: "timeout" }),
-      resolve2
+      resolve
     );
     child.stdout.on("data", (chunk) => {
       if (gate.settled()) return;
@@ -2110,7 +2022,7 @@ function runProcess(cwd, command, args, timeoutMs, maxStdoutBytes) {
         exitCode: code ?? 0
       }),
       (err) => ({ kind: "spawn_error", message: err.message }),
-      resolve2
+      resolve
     );
   });
 }
@@ -2191,11 +2103,11 @@ function resolveSearchScope(path$1, projectRoot, allowAbsolute) {
     return { scopeAbs: scopeRel };
   }
   try {
-    const scopeAbs = scopeRel === "." ? projectRoot : safePathJoin(projectRoot, scopeRel);
-    assertNoSymlinkEscape(scopeAbs, projectRoot);
+    const scopeAbs = scopeRel === "." ? projectRoot : pathSafety.safePathJoin(projectRoot, scopeRel);
+    pathSafety.assertNoSymlinkEscape(scopeAbs, projectRoot);
     return { scopeAbs };
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return { error: JSON.stringify({ ok: false, error: "path_traversal", path: path$1 }) };
     }
     throw err;
@@ -2204,7 +2116,7 @@ function resolveSearchScope(path$1, projectRoot, allowAbsolute) {
 async function handleEntry(entry, absDir, state) {
   const entryAbs = path.join(absDir, entry.name);
   const entryRel = path.relative(state.projectRoot, entryAbs);
-  if (isForbiddenPath(entryRel)) return;
+  if (pathSafety.isForbiddenPath(entryRel)) return;
   if (entry.isDirectory()) {
     await walk(entryAbs, state);
     return;
@@ -2270,10 +2182,10 @@ function resolveScopeRel(path$1, projectRoot, allowAbsolute) {
   if (scopeRel === "") return { rel: "" };
   if (allowAbsolute && path.isAbsolute(scopeRel)) return { rel: scopeRel };
   try {
-    assertNoSymlinkEscape(safePathJoin(projectRoot, scopeRel), projectRoot);
+    pathSafety.assertNoSymlinkEscape(pathSafety.safePathJoin(projectRoot, scopeRel), projectRoot);
     return { rel: scopeRel };
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return { error: JSON.stringify({ ok: false, error: "path_traversal", path: path$1 }) };
     }
     throw err;
@@ -2295,7 +2207,7 @@ async function walkBackend(backend, dirRel, state, depth) {
 }
 async function handleBackendEntry(backend, dirRel, name, state, depth) {
   const entryRel = dirRel === "" ? name : `${dirRel}/${name}`;
-  if (isForbiddenPath(entryRel)) return;
+  if (pathSafety.isForbiddenPath(entryRel)) return;
   let st;
   try {
     st = await backend.stat(entryRel);
@@ -2361,7 +2273,7 @@ function createShellTool(opts) {
   });
 }
 function runShell(cwd, command, timeoutMs) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const child = child_process.spawn("/bin/sh", ["-c", command], {
       cwd,
       detached: true,
@@ -2375,7 +2287,7 @@ function runShell(cwd, command, timeoutMs) {
       child,
       timeoutMs,
       () => ({ kind: "timeout" }),
-      (result) => resolve2(formatResult(result, timeoutMs))
+      (result) => resolve(formatResult(result, timeoutMs))
     );
     child.stdout.on("data", (chunk) => {
       if (gate.settled()) return;
@@ -2413,7 +2325,7 @@ function runShell(cwd, command, timeoutMs) {
         exitCode: code
       }),
       (err) => ({ kind: "error", message: err.message }),
-      (result) => resolve2(formatResult(result, timeoutMs))
+      (result) => resolve(formatResult(result, timeoutMs))
     );
   });
 }
@@ -2795,7 +2707,7 @@ function createWriteFileTool(opts) {
       content: zod.z.string().describe("UTF-8 content to write.")
     }),
     handler: async ({ path, content }, ctx) => {
-      if (isForbiddenPath(path)) {
+      if (pathSafety.isForbiddenPath(path)) {
         return JSON.stringify({ ok: false, error: "forbidden_path", path });
       }
       if (filesystem$1) {
@@ -2817,10 +2729,10 @@ function readBeforeWriteError(guard, path, currentMtimeMs) {
 async function writeViaLocalFs(projectRoot, path$1, content, guard) {
   let absolutePath;
   try {
-    absolutePath = safePathJoin(projectRoot, path$1);
-    assertNoSymlinkEscape(absolutePath, projectRoot);
+    absolutePath = pathSafety.safePathJoin(projectRoot, path$1);
+    pathSafety.assertNoSymlinkEscape(absolutePath, projectRoot);
   } catch (err) {
-    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+    if (err instanceof pathSafety.PathTraversalError || err instanceof pathSafety.ForbiddenPathError) {
       return JSON.stringify({ ok: false, error: "path_traversal", path: path$1 });
     }
     throw err;