@cjhyy/code-shell-capability-coding 0.8.20 → 0.9.0

package/dist/tools/apply-patch/applier.d.ts

@@ -2,6 +2,8 @@ import { Hunk } from "./types.js";
 export interface ApplyPatchOptions {
     /** Working directory for resolving relative paths in the patch. */
     cwd: string;
+    /** Immutable roots authorized for this run. Relative patch paths still resolve from cwd. */
+    workspaceRoots?: readonly string[];
     /**
      * If true, skip the snapshot/rollback safety net and apply each planned
      * change one at a time, leaving partial work on disk if a later write

package/dist/tools/apply-patch/applier.js

@@ -27,10 +27,10 @@ export async function applyPatch(hunks, options) {
     if (hunks.length === 0) {
         throw new Error("No files were modified.");
     }
-    const planned = await planHunks(hunks, options.cwd);
+    const planned = await planHunks(hunks, options.cwd, options.workspaceRoots ?? [options.cwd]);
     return commitPlanned(planned, !!options.allowPartialOnCommit);
 }
-async function planHunks(hunks, cwd) {
+async function planHunks(hunks, cwd, workspaceRoots) {
     const set = {
         byPath: new Map(),
         added: [],
@@ -45,7 +45,7 @@ async function planHunks(hunks, cwd) {
     }
     for (const hunk of hunks) {
         const original = hunk.path;
-        const sourcePath = resolveAgainst(original, cwd);
+        const sourcePath = resolveAgainst(original, cwd, workspaceRoots);
         if (hunk.kind === "add") {
             const existed = await readIfExists(sourcePath);
             schedule(sourcePath, {
@@ -87,7 +87,7 @@ async function planHunks(hunks, cwd) {
         const originalText = toLf(originalRaw);
         const newText = applyEol(applyChunksToText(originalText, hunk.chunks, sourcePath), eol);
         if (hunk.movePath !== undefined) {
-            const destPath = resolveAgainst(hunk.movePath, cwd);
+            const destPath = resolveAgainst(hunk.movePath, cwd, workspaceRoots);
             if (destPath === sourcePath) {
                 // Rename to self → degenerate update.
                 schedule(sourcePath, {
@@ -248,12 +248,12 @@ async function writeChange(change) {
  * symlink planted inside cwd that points outside — a plain string `resolve()`
  * would look contained while the write follows the link out.
  */
-function resolveAgainst(p, cwd) {
+function resolveAgainst(p, cwd, workspaceRoots) {
     const resolved = isAbsolute(p) ? p : resolve(cwd, p);
-    const realCwd = nearestRealPath(cwd);
     const realTarget = nearestRealPath(resolved);
-    if (!isInside(realTarget, realCwd)) {
-        throw new Error(`Refusing to apply patch outside the working directory: "${p}" resolves to "${realTarget}", which escapes "${realCwd}".`);
+    const realRoots = workspaceRoots.map(nearestRealPath);
+    if (!realRoots.some((root) => isInside(realTarget, root))) {
+        throw new Error(`Refusing to apply patch outside the workspace roots: "${p}" resolves to "${realTarget}".`);
     }
     return resolved;
 }

package/dist/tools/apply-patch/index.js

@@ -72,7 +72,10 @@ export async function applyPatchTool(args, ctx) {
     const cwd = ctx?.cwd ?? process.cwd();
     let result;
     try {
-        result = await applyPatch(parsed.hunks, { cwd });
+        result = await applyPatch(parsed.hunks, {
+            cwd,
+            workspaceRoots: ctx?.workspace?.roots.map((root) => root.path),
+        });
     }
     catch (err) {
         return `Error applying patch: ${err.message}`;

package/dist/tools/worktree.js

@@ -27,7 +27,7 @@ export async function switchSessionWorkspaceTool(args, ctx) {
     const target = stringArg(args.target);
     if (!target)
         return "Error: target is required";
-    const bridge = ctx?.workspace;
+    const bridge = workspaceBridgeForContext(ctx);
     if (!bridge) {
         return ("SwitchSessionWorkspace is not available in this host. " +
             "Use the host's supported workspace controls instead.");
@@ -48,6 +48,22 @@ export async function switchSessionWorkspaceTool(args, ctx) {
         return `Error: switching workspace failed: ${err.message}`;
     }
 }
+function workspaceBridgeForContext(ctx) {
+    if (ctx?.workspaceBridge)
+        return ctx.workspaceBridge;
+    // Before multi-root authority landed, the host bridge occupied `workspace`.
+    // Keep those single-root hosts and injected harnesses working, but never
+    // interpret a versioned/root-bearing WorkspaceContext as an executable bridge.
+    const legacy = ctx?.workspace;
+    if (!legacy || typeof legacy !== "object")
+        return undefined;
+    if ("version" in legacy || "roots" in legacy || "projectId" in legacy)
+        return undefined;
+    const candidate = legacy;
+    return typeof candidate.switch === "function"
+        ? candidate
+        : undefined;
+}
 export const enterWorktreeToolDef = {
     name: "EnterWorktree",
     description: "Switch the current session workspace. Target can be a new worktree slug, " +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-capability-coding",
-  "version": "0.8.20",
+  "version": "0.9.0",
   "description": "Coding capability pack for the generic code-shell agent core.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.8.20"
+    "@cjhyy/code-shell-core": "0.9.0"
   },
   "engines": {
     "node": ">=20.10"