code-workspace-zhuiyi 0.1.0-beta.1

package/src/core/permissions/codex.js

@@ -0,0 +1,126 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { WorkspaceError } = require("../errors");
+const { atomicWrite } = require("../fs");
+const { assertFingerprint, planDirectoryMutation, readTarget } = require("./common");
+
+const START = "# BEGIN workspace-permissions:code-workspace";
+const END = "# END workspace-permissions:code-workspace";
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function blockPattern(start = START, end = END) {
+  return new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`, "g");
+}
+
+function render(directories) {
+  const roots = directories.map((directory) => `  ${JSON.stringify(directory)},`).join("\n");
+  return `${START}\nsandbox_mode = "workspace-write"\napproval_policy = "on-request"\n\n[sandbox_workspace_write]\nwritable_roots = [\n${roots}\n]\n${END}\n`;
+}
+
+function managedBlock(text) {
+  return text.match(blockPattern())?.[0] || null;
+}
+
+function parseManagedRoots(text, file) {
+  const block = managedBlock(text);
+  if (!block) return [];
+  const array = block.match(/writable_roots\s*=\s*\[([\s\S]*?)\]/)?.[1] || "";
+  const roots = [];
+  for (const line of array.split(/\r?\n/)) {
+    const value = line.trim().replace(/,$/, "");
+    if (!value) continue;
+    try {
+      const parsed = JSON.parse(value);
+      if (typeof parsed !== "string") throw new Error("entry is not a string");
+      roots.push(parsed);
+    } catch (error) {
+      throw new WorkspaceError("CODEX_PERMISSION_CONFIG_INVALID", `Cannot parse Codex writable root in ${file}: ${error.message}`, { file });
+    }
+  }
+  return roots;
+}
+
+function unmanagedConflicts(text) {
+  const stripped = text.replace(blockPattern(), "");
+  const conflicts = [];
+  let section = "";
+  for (const line of stripped.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const header = trimmed.match(/^\[([^\]]+)\]$/);
+    if (header) {
+      section = header[1];
+      if (section === "sandbox_workspace_write") conflicts.push("[sandbox_workspace_write]");
+      continue;
+    }
+    if (!section && /^(sandbox_mode|approval_policy)\s*=/.test(trimmed)) conflicts.push(trimmed.split("=")[0].trim());
+  }
+  return [...new Set(conflicts)];
+}
+
+function desiredContent(current, directories) {
+  const outside = current.replace(blockPattern(), "").replace(/^\s+/, "");
+  const desired = `${render(directories)}${outside ? `\n${outside}` : ""}`;
+  return desired.endsWith("\n") ? desired : `${desired}\n`;
+}
+
+const codexPermissionAdapter = {
+  id: "codex",
+  targets(root) {
+    return [path.join(root, ".codex", "config.toml")];
+  },
+  inspect(root) {
+    const target = readTarget(this.targets(root)[0]);
+    const conflicts = unmanagedConflicts(target.content);
+    if (conflicts.length > 0) {
+      throw new WorkspaceError("WORKSPACE_PERMISSIONS_CONFLICT", `Unmanaged Codex sandbox configuration conflicts: ${conflicts.join(", ")}`, {
+        tool: this.id,
+        file: target.file,
+        conflicts,
+      });
+    }
+    return { ...target, directories: parseManagedRoots(target.content, target.file) };
+  },
+  plan({ current, grants, revokes }) {
+    const mutation = planDirectoryMutation(current.directories, grants, revokes);
+    return {
+      tool: this.id,
+      target: current.file,
+      targets: [current.file],
+      fingerprint: current.fingerprint,
+      ...mutation,
+      desiredContent: mutation.action === "write" ? desiredContent(current.content, mutation.desired) : current.content,
+    };
+  },
+  assertCurrent(plan) {
+    assertFingerprint(plan);
+  },
+  apply(plan, options = {}) {
+    (options.atomicWrite || atomicWrite)(plan.target, plan.desiredContent);
+  },
+  verify(plan) {
+    let actual;
+    try {
+      actual = fs.readFileSync(plan.target, "utf8");
+    } catch (error) {
+      throw new WorkspaceError("WORKSPACE_PERMISSION_VERIFY_FAILED", `Cannot verify Codex directory authorization: ${error.message}`, {
+        tool: this.id,
+        file: plan.target,
+        remediation: "Inspect .codex/config.toml and re-run code-w permissions apply.",
+      });
+    }
+    if (actual !== plan.desiredContent) {
+      throw new WorkspaceError("WORKSPACE_PERMISSION_VERIFY_FAILED", "Codex directory authorization does not match the confirmed plan.", {
+        tool: this.id,
+        file: plan.target,
+        remediation: "Inspect .codex/config.toml and re-run code-w permissions apply.",
+      });
+    }
+  },
+};
+
+module.exports = { END, START, blockPattern, codexPermissionAdapter, parseManagedRoots, render, unmanagedConflicts };

package/src/core/permissions/common.js

@@ -0,0 +1,44 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { WorkspaceError } = require("../errors");
+const { sha256 } = require("../fs");
+
+function readTarget(file) {
+  const exists = fs.existsSync(file);
+  const content = exists ? fs.readFileSync(file, "utf8") : "";
+  return { file, exists, content, fingerprint: exists ? sha256(content) : null };
+}
+
+function assertFingerprint(plan) {
+  const actual = readTarget(plan.target);
+  if (actual.fingerprint !== plan.fingerprint) {
+    throw new WorkspaceError("WORKSPACE_PERMISSION_PLAN_STALE", `Agent permission target changed after planning: ${plan.target}`, {
+      tool: plan.tool,
+      file: plan.target,
+      expectedFingerprint: plan.fingerprint,
+      actualFingerprint: actual.fingerprint,
+      remediation: "Review the changed Agent settings and retry the command.",
+    });
+  }
+}
+
+function normalizedExistingDirectory(value) {
+  return typeof value === "string" && path.isAbsolute(value) ? path.resolve(value) : null;
+}
+
+function planDirectoryMutation(currentDirectories, grants, revokes) {
+  const currentNormalized = currentDirectories.map(normalizedExistingDirectory);
+  const granted = grants.filter((directory) => !currentNormalized.includes(directory));
+  const revoked = revokes.filter((directory) => currentNormalized.includes(directory));
+  const unchanged = [
+    ...grants.filter((directory) => currentNormalized.includes(directory)),
+    ...revokes.filter((directory) => !currentNormalized.includes(directory)),
+  ];
+  const revokedSet = new Set(revoked);
+  const desired = currentDirectories.filter((directory, index) => !revokedSet.has(currentNormalized[index]));
+  for (const directory of granted) desired.push(directory);
+  return { action: granted.length > 0 || revoked.length > 0 ? "write" : "skip", granted, revoked, unchanged, desired };
+}
+
+module.exports = { assertFingerprint, normalizedExistingDirectory, planDirectoryMutation, readTarget };

package/src/core/permissions/index.js

@@ -0,0 +1,163 @@
+const path = require("node:path");
+
+const { WorkspaceError } = require("../errors");
+const { createFileTransaction } = require("../transaction");
+const { claudePermissionAdapter } = require("./claude");
+const { codexPermissionAdapter } = require("./codex");
+
+const permissionAdapters = new Map([
+  [claudePermissionAdapter.id, claudePermissionAdapter],
+  [codexPermissionAdapter.id, codexPermissionAdapter],
+]);
+
+function normalizeDirectories(values, label) {
+  const normalized = [];
+  for (const value of values || []) {
+    if (typeof value !== "string" || !value.trim() || !path.isAbsolute(value.trim())) {
+      throw new WorkspaceError("WORKSPACE_PERMISSION_DIRECTORY_INVALID", `${label} directories must be non-empty absolute paths.`, {
+        label,
+        directory: value ?? null,
+      });
+    }
+    const directory = path.resolve(value.trim());
+    if (!normalized.includes(directory)) normalized.push(directory);
+  }
+  return normalized;
+}
+
+function resolvePermissionAdapters(tools) {
+  return [...new Set(tools || [])].map((tool) => {
+    const adapter = permissionAdapters.get(tool);
+    if (!adapter) {
+      throw new WorkspaceError(
+        "WORKSPACE_PERMISSION_TOOL_UNSUPPORTED",
+        `Agent tool does not support workspace directory authorization: ${tool}`,
+        { tool, remediation: "Select a permission-capable tool or install a Code Workspace release that supports it." }
+      );
+    }
+    return adapter;
+  });
+}
+
+function permissionTargets(root, tools) {
+  return resolvePermissionAdapters(tools).flatMap((adapter) => adapter.targets(root));
+}
+
+function planPermissionChanges({ root, tools, grants = [], revokes = [] }, options = {}) {
+  const normalizedGrants = normalizeDirectories(grants, "grant");
+  const normalizedRevokes = normalizeDirectories(revokes, "revoke");
+  const overlap = normalizedGrants.filter((directory) => normalizedRevokes.includes(directory));
+  if (overlap.length > 0) {
+    throw new WorkspaceError("WORKSPACE_PERMISSION_REQUEST_CONFLICT", `Directories cannot be granted and revoked in one request: ${overlap.join(", ")}`, {
+      directories: overlap,
+    });
+  }
+  const adapters = resolvePermissionAdapters(tools);
+  if (normalizedGrants.length === 0 && normalizedRevokes.length === 0) {
+    const plans = adapters.map((adapter) => {
+      const target = adapter.targets(root)[0];
+      return { tool: adapter.id, target, targets: [target], action: "skip", granted: [], revoked: [], unchanged: [], passive: true };
+    });
+    return {
+      root: path.resolve(root),
+      tools: adapters.map((adapter) => adapter.id),
+      requested: { grants: [], revokes: [] },
+      action: "skip",
+      targets: plans.flatMap((plan) => plan.targets),
+      plans,
+    };
+  }
+  const plans = adapters.map((adapter) => {
+    const current = adapter.inspect(root, options);
+    return adapter.plan({ root, current, grants: normalizedGrants, revokes: normalizedRevokes });
+  });
+  return {
+    root: path.resolve(root),
+    tools: adapters.map((adapter) => adapter.id),
+    requested: { grants: normalizedGrants, revokes: normalizedRevokes },
+    action: plans.some((plan) => plan.action === "write") ? "write" : "skip",
+    targets: plans.flatMap((plan) => plan.targets),
+    plans,
+  };
+}
+
+function permissionResult(plan) {
+  return {
+    action: plan.action,
+    requestedTools: plan.tools,
+    requested: plan.requested,
+    tools: plan.plans.map((toolPlan) => ({
+      tool: toolPlan.tool,
+      target: path.relative(plan.root, toolPlan.target),
+      action: toolPlan.action,
+      granted: toolPlan.granted,
+      revoked: toolPlan.revoked,
+      unchanged: toolPlan.unchanged,
+      verified: true,
+    })),
+  };
+}
+
+function applyPermissionPlan(plan, options = {}) {
+  const transaction = options.transaction || createFileTransaction(plan.targets);
+  const ownsTransaction = !options.transaction;
+  try {
+    for (const toolPlan of plan.plans) {
+      if (toolPlan.passive) continue;
+      const adapter = permissionAdapters.get(toolPlan.tool);
+      adapter.assertCurrent(toolPlan, options);
+    }
+    for (const toolPlan of plan.plans) {
+      if (toolPlan.action === "skip") continue;
+      const adapter = permissionAdapters.get(toolPlan.tool);
+      adapter.apply(toolPlan, options);
+      options.injectFailure?.(`after-${toolPlan.tool}-permission-write`, toolPlan);
+    }
+    for (const toolPlan of plan.plans) {
+      if (toolPlan.action === "skip") continue;
+      const adapter = permissionAdapters.get(toolPlan.tool);
+      adapter.verify(toolPlan, options);
+      options.injectFailure?.(`after-${toolPlan.tool}-permission-verify`, toolPlan);
+    }
+    if (ownsTransaction) transaction.commit();
+    return permissionResult(plan);
+  } catch (error) {
+    if (ownsTransaction) transaction.rollback(error);
+    throw error;
+  }
+}
+
+function inspectProjectPermissions({ root, tools, projects }, options = {}) {
+  const directories = normalizeDirectories((projects || []).map((project) => project.location), "project");
+  return resolvePermissionAdapters(tools).map((adapter) => {
+    const current = adapter.inspect(root, options);
+    const authorized = new Set(current.directories);
+    return {
+      tool: adapter.id,
+      target: path.relative(path.resolve(root), current.file),
+      directories: current.directories,
+      missing: directories.filter((directory) => !authorized.has(directory)),
+    };
+  });
+}
+
+function formatPermissionPlan(plan) {
+  const lines = [];
+  for (const toolPlan of plan.plans) {
+    for (const directory of toolPlan.granted) lines.push(`  GRANT  ${directory} (${toolPlan.tool})`);
+    for (const directory of toolPlan.revoked) lines.push(`  REVOKE ${directory} (${toolPlan.tool})`);
+  }
+  if (lines.length === 0) return "No Agent authorization changes are required.";
+  return ["Agent authorization changes:", ...lines, "Affected files:", ...plan.plans.filter((entry) => entry.action === "write").map((entry) => `  ${path.relative(plan.root, entry.target)}`)].join("\n");
+}
+
+module.exports = {
+  applyPermissionPlan,
+  formatPermissionPlan,
+  inspectProjectPermissions,
+  normalizeDirectories,
+  permissionAdapters,
+  permissionTargets,
+  planPermissionChanges,
+  resolvePermissionAdapters,
+};