flavor-code 1.2.4 → 1.2.5

package/dist/desktop/main.js

@@ -2953,10 +2953,12 @@ function getToolCategory(name) {
   return isNetworkTool(name) ? "network" : CATEGORY_MAP[name] ?? "unknown";
 }
 var PermissionEngine = class {
+  #lexicalWorkspace;
   #workspace;
   #mode;
   constructor(options) {
     const root = resolve2(options.workspace);
+    this.#lexicalWorkspace = root;
     this.#workspace = existsSync(root) ? realpathSync.native(root) : root;
     this.#mode = canonicalMode(options.mode ?? "default");
   }
@@ -2977,13 +2979,13 @@ var PermissionEngine = class {
       return { decision: "deny", reason: `${request.tool} requires source and destination paths` };
     }
     for (const path of paths) {
-      const classification = classifyPath(this.#workspace, path);
+      const classification = classifyPath(this.#lexicalWorkspace, this.#workspace, path);
       if (classification.escape) return { decision: "deny", reason: classification.reason ?? "Path escapes the workspace" };
       if (request.agent === "subagent" && !classification.inside) {
         return { decision: "deny", reason: "Subagents are restricted to the workspace" };
       }
     }
-    const inside = paths.every((path) => classifyPath(this.#workspace, path).inside);
+    const inside = paths.every((path) => classifyPath(this.#lexicalWorkspace, this.#workspace, path).inside);
     if (this.#mode === "plan") {
       return READ_TOOLS.has(request.tool) ? { decision: "allow" } : { decision: "deny", reason: "Plan mode is read-only" };
     }
@@ -3010,11 +3012,11 @@ var PermissionEngine = class {
     const analysis = request.args === void 0 ? analyzeCommand(request.command ?? "") : analyzeArgumentCommand(request.command ?? "", request.args);
     if (request.agent === "subagent") {
       if (request.cwd === void 0) return { decision: "ask", reason: "Subagent shell commands require an explicit workspace cwd" };
-      const cwd = classifyPath(this.#workspace, request.cwd);
+      const cwd = classifyPath(this.#lexicalWorkspace, this.#workspace, request.cwd);
       if (cwd.escape || !cwd.inside) return { decision: "deny", reason: "Subagent shell cwd must remain in the workspace" };
       if (analysis.destructive) return { decision: "deny", reason: "Destructive commands are forbidden for subagents" };
       if (analysis.wrapped || analysis.opaque || !isRoutineCommand(analysis.command)) return { decision: "ask", reason: "Subagent shell command requires main-Agent approval" };
-      const argumentDecision = assessRoutineArguments(analysis.command, request.cwd, this.#workspace);
+      const argumentDecision = assessRoutineArguments(analysis.command, request.cwd, this.#lexicalWorkspace, this.#workspace);
       if (argumentDecision !== "allow") {
         return argumentDecision === "deny" ? { decision: "deny", reason: "Subagent command arguments escape the workspace" } : { decision: "ask", reason: "Ambiguous subagent command arguments require main-Agent approval" };
       }
@@ -3026,12 +3028,12 @@ var PermissionEngine = class {
     if (analysis.wrapped || analysis.opaque) return ask(this.#mode, "Shell wrapper requires approval");
     if (this.#mode === "bypassPermissions") return { decision: "allow" };
     if ((this.#mode === "acceptEdits" || this.#mode === "auto") && isRoutineCommand(analysis.command)) {
-      const cwd = request.cwd ?? this.#workspace;
-      const cwdClassification = classifyPath(this.#workspace, cwd);
+      const cwd = request.cwd ?? this.#lexicalWorkspace;
+      const cwdClassification = classifyPath(this.#lexicalWorkspace, this.#workspace, cwd);
       if (cwdClassification.escape || !cwdClassification.inside) {
         return { decision: "deny", reason: "Routine command cwd must remain in the workspace" };
       }
-      const argumentDecision = assessRoutineArguments(analysis.command, cwd, this.#workspace);
+      const argumentDecision = assessRoutineArguments(analysis.command, cwd, this.#lexicalWorkspace, this.#workspace);
       if (argumentDecision === "deny") return { decision: "deny", reason: "Routine command arguments escape the workspace" };
       if (argumentDecision === "ask") return ask(this.#mode, "Ambiguous routine command arguments require approval");
       return { decision: "allow" };
@@ -3068,16 +3070,16 @@ function analyzeArgumentCommand(executable, args) {
   }
   return { command, destructive: isForbiddenCommand(command), opaque: false, wrapped: false };
 }
-function classifyPath(workspace, input) {
-  const candidate = resolve2(workspace, input);
-  const lexicalInside = isWithin(workspace, candidate);
+function classifyPath(lexicalWorkspace, physicalWorkspace, input) {
+  const candidate = resolve2(lexicalWorkspace, input);
+  const lexicalInside = isWithin(lexicalWorkspace, candidate);
   const traversal = input.split(/[\\/]+/).includes("..");
-  const startsInWorkspace = pathStartsWith(workspace, input);
+  const startsInWorkspace = pathStartsWith(lexicalWorkspace, input);
   if ((!isAbsolute(input) || startsInWorkspace) && traversal && !lexicalInside) {
     return { inside: false, escape: true, reason: "Path traversal escapes the workspace" };
   }
   const physical = resolvePhysical(candidate);
-  const physicalInside = isWithin(workspace, physical);
+  const physicalInside = isWithin(physicalWorkspace, physical);
   if (lexicalInside && !physicalInside) return { inside: false, escape: true, reason: "Symlink escapes the workspace" };
   return { inside: physicalInside, escape: false };
 }
@@ -3167,7 +3169,7 @@ function isRoutineCommand(command) {
   if (command.executable === "go") return first === "test";
   return ["pytest", "vitest", "jest", "eslint", "tsc"].includes(command.executable);
 }
-function assessRoutineArguments(command, cwd, workspace) {
+function assessRoutineArguments(command, cwd, lexicalWorkspace, physicalWorkspace) {
   const args = routineArguments(command);
   if (args === void 0) return "ask";
   const pathOptions = /* @__PURE__ */ new Set([
@@ -3192,7 +3194,7 @@ function assessRoutineArguments(command, cwd, workspace) {
       const option2 = equals[1]?.toLowerCase() ?? "";
       const value = equals[2] ?? "";
       if (!pathOptions.has(option2)) return "ask";
-      const decision = assessArgumentPath(value, cwd, workspace);
+      const decision = assessArgumentPath(value, cwd, lexicalWorkspace, physicalWorkspace);
       if (decision !== "allow") return decision;
       continue;
     }
@@ -3200,14 +3202,14 @@ function assessRoutineArguments(command, cwd, workspace) {
     if (option !== void 0 && pathOptions.has(option)) {
       const value = args[index + 1];
       if (value === void 0 || value.startsWith("-")) return "ask";
-      const decision = assessArgumentPath(value, cwd, workspace);
+      const decision = assessArgumentPath(value, cwd, lexicalWorkspace, physicalWorkspace);
       if (decision !== "allow") return decision;
       index += 1;
       continue;
     }
     if (arg.startsWith("-")) continue;
     if (looksLikePath(arg)) {
-      const decision = assessArgumentPath(arg, cwd, workspace);
+      const decision = assessArgumentPath(arg, cwd, lexicalWorkspace, physicalWorkspace);
       if (decision !== "allow") return decision;
       continue;
     }
@@ -3225,10 +3227,10 @@ function routineArguments(command) {
   if (["pytest", "vitest", "jest", "eslint", "tsc"].includes(command.executable)) return command.args;
   return void 0;
 }
-function assessArgumentPath(value, cwd, workspace) {
+function assessArgumentPath(value, cwd, lexicalWorkspace, physicalWorkspace) {
   if (value.length === 0) return "ask";
   const resolved = resolve2(cwd, value);
-  const classification = classifyPath(workspace, resolved);
+  const classification = classifyPath(lexicalWorkspace, physicalWorkspace, resolved);
   return classification.escape || !classification.inside ? "deny" : "allow";
 }
 function looksLikePath(value) {
@@ -3477,7 +3479,8 @@ var ToolRuntime = class {
         } catch {
         }
       }
-      if (pre.decision === "ask" || permission.decision === "ask") {
+      const sessionAllowed = this.#alwaysAllowed.has(getToolCategory(tool.name));
+      if (!sessionAllowed && (pre.decision === "ask" || permission.decision === "ask")) {
         const reason = [pre.reason, permission.reason].filter((value) => value !== void 0).join("\n") || "Approval required";
         const requestDecision = await this.#hooks.emit({
           version: 1,
@@ -3502,8 +3505,7 @@ var ToolRuntime = class {
           throw signal.reason;
         } else {
           const category = getToolCategory(tool.name);
-          if (this.#alwaysAllowed.has(category)) {
-          } else if (this.#approve === void 0) {
+          if (this.#approve === void 0) {
             return this.#fail(tool.name, input, context.agent, "permission_denied", reason);
           } else {
             const decision = await this.#approve({ ...request, reason }, signal);
@@ -8251,9 +8253,11 @@ var SkillRegistry = class {
     for (const configuredRoot of roots) {
       const root = resolve11(configuredRoot);
       let entries;
+      let physicalRoot = root;
       try {
         const rootInfo = await lstat5(root);
         if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory()) throw new Error("Skill root must be a real directory");
+        physicalRoot = await realpath4(root);
         entries = await readdir4(root, { withFileTypes: true });
       } catch (error) {
         if (isMissing(error)) continue;
@@ -8266,12 +8270,12 @@ var SkillRegistry = class {
         try {
           if (entry2.isSymbolicLink()) throw new Error("Symlinked skill directories are not allowed");
           if (!entry2.isDirectory()) continue;
-          const physicalRoot = await realpath4(skillRoot);
-          if (!isWithin3(root, physicalRoot)) throw new Error("Skill directory escapes its registry root");
+          const physicalSkillRoot = await realpath4(skillRoot);
+          if (!isWithin3(physicalRoot, physicalSkillRoot)) throw new Error("Skill directory escapes its registry root");
           const skillFile = resolve11(skillRoot, "SKILL.md");
           const parsed = await readFrontmatterFile(
             skillFile,
-            physicalRoot,
+            physicalSkillRoot,
             this.#options.maxMetadataBytes,
             this.#options.openFile
           );
@@ -8282,7 +8286,7 @@ var SkillRegistry = class {
               name: parsed.name,
               description: parsed.description,
               source,
-              root: physicalRoot,
+              root: physicalSkillRoot,
               disableModelInvocation: parsed.disableModelInvocation
             }),
             skillFile
@@ -10513,6 +10517,7 @@ function createEditTool(workspace, options = {}) {
     paths: (input) => [guard.lexical(input.path)],
     execute: async (input, signal) => {
       abortIfNeeded(signal);
+      const displayPath = guard.lexical(input.path);
       const path = await guard.existing(input.path);
       const contents = await readText(path);
       const hasCRLF = contents.includes("\r\n");
@@ -10528,11 +10533,11 @@ function createEditTool(workspace, options = {}) {
       }
       const updatedLF = contentsLF.slice(0, first) + newTextLF + contentsLF.slice(first + oldTextLF.length);
       const updated = hasCRLF ? updatedLF.replace(/\n/g, "\r\n") : updatedLF;
-      await options.beforeCommit?.({ path, before: contents, after: updated, kind: "update" }, signal);
+      await options.beforeCommit?.({ path: displayPath, before: contents, after: updated, kind: "update" }, signal);
       await atomicWrite(path, updated, signal);
       return withToolPresentation(
-        { path, replacements: 1 },
-        buildFileChangePresentation(path, contents, updated, "update")
+        { path: displayPath, replacements: 1 },
+        buildFileChangePresentation(displayPath, contents, updated, "update")
       );
     }
   };

package/dist/sdk/index.js

@@ -4,7 +4,7 @@ import {
   FlavorRpcServer,
   TraceRecordSchema,
   TraceRecorder
-} from "../chunk-L5A2NDMT.js";
+} from "../chunk-Z3BW52MK.js";
 import {
   AgentMessageQueue,
   DockerExecutionEnvironment,
@@ -13,7 +13,7 @@ import {
   WorkspaceCheckpointStore,
   buildDockerInvocation,
   createProductionRuntime
-} from "../chunk-MRISY6KK.js";
+} from "../chunk-3TYRDK34.js";
 import "../chunk-HFR2WS6T.js";
 import "../chunk-N2S7USST.js";
 import "../chunk-S32JRDZK.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flavor-code",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "author": "YachuanWzh",
   "type": "module",
   "publishConfig": {
@@ -21,6 +21,7 @@
     "dist/",
     "!dist/**/*.map",
     "README.md",
+    "README.zh-CN.md",
     "技术方案报告.md",
     "LICENSE"
   ],