@jingyi0605/codingns 0.3.6 → 0.5.0

package/dist/server/modules/sessions/session-permission-request-service.js

@@ -1,4 +1,4 @@
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { AppError } from "../../shared/errors/app-error.js";
 import { logPermissionDebug } from "../../shared/utils/permission-debug-log.js";
 import { createId } from "../../shared/utils/id.js";
@@ -197,6 +197,38 @@ export class SessionPermissionRequestService {
                 bridgeResponse: buildClaudePreToolUseBridgeResponse("allow", "CodingNS 已按本会话默认允许自动放行")
             };
         }
+        const safeAssistantCliReason = resolveClaudeAssistantCliAutoApprovalReason(normalized.command);
+        if (safeAssistantCliReason) {
+            logPermissionDebug("claude_permission.pre_tool_use.auto_allow_safe_assistant_cli", {
+                sessionId: binding.sessionId,
+                providerSessionId,
+                toolName: payload.tool_name ?? null,
+                command: normalized.command,
+                reason: safeAssistantCliReason
+            });
+            return {
+                accepted: true,
+                ignored: false,
+                sessionId: binding.sessionId,
+                bridgeResponse: buildClaudePreToolUseBridgeResponse("allow", safeAssistantCliReason)
+            };
+        }
+        const safeShellReason = resolveClaudeSafeShellAutoApprovalReason(normalized.command);
+        if (safeShellReason) {
+            logPermissionDebug("claude_permission.pre_tool_use.auto_allow_safe_shell", {
+                sessionId: binding.sessionId,
+                providerSessionId,
+                toolName: payload.tool_name ?? null,
+                command: normalized.command,
+                reason: safeShellReason
+            });
+            return {
+                accepted: true,
+                ignored: false,
+                sessionId: binding.sessionId,
+                bridgeResponse: buildClaudePreToolUseBridgeResponse("allow", safeShellReason)
+            };
+        }
         let resolvedByTimeout = false;
         const decision = await new Promise((resolve) => {
             const timer = setTimeout(() => {
@@ -302,6 +334,21 @@ export class SessionPermissionRequestService {
             payload,
             createdAt: now
         });
+        const allowedScopeKey = buildClaudeAllowedScopeKey(normalized);
+        if (allowedScopeKey && this.isClaudeScopeAllowed(binding.sessionId, allowedScopeKey)) {
+            logPermissionDebug("claude_permission.permission_request.auto_allow_session", {
+                sessionId: binding.sessionId,
+                providerSessionId,
+                toolName: payload.tool_name ?? null,
+                scopeKey: allowedScopeKey
+            });
+            return {
+                accepted: true,
+                ignored: false,
+                sessionId: binding.sessionId,
+                bridgeResponse: buildClaudePermissionRequestBridgeResponse("allow", "CodingNS 已按本会话默认允许自动放行")
+            };
+        }
         let resolvedByTimeout = false;
         const decision = await new Promise((resolve) => {
             const timer = setTimeout(() => {
@@ -949,7 +996,12 @@ export function normalizeClaudePreToolUseRequest(input) {
         paths: normalized.paths,
         permissionProfile: null,
         questions: [],
-        actions: buildClaudeActions(normalized.kind),
+        actions: buildClaudeActions({
+            kind: normalized.kind,
+            command: normalized.command,
+            paths: normalized.paths,
+            toolName
+        }),
         rawPayload,
         createdAt: input.createdAt,
         updatedAt: input.createdAt,
@@ -1344,6 +1396,7 @@ function resolveCodexReplyStatus(kind, action) {
 function buildClaudeKind(toolName, toolInput) {
     const normalizedToolName = toolName.trim().toLowerCase();
     const inputRecord = toRecord(toolInput);
+    const paths = readClaudePaths(inputRecord);
     const command = normalizeText(inputRecord?.command) ||
         normalizeText(inputRecord?.cmd) ||
         null;
@@ -1376,7 +1429,7 @@ function buildClaudeKind(toolName, toolInput) {
         summary: toolName,
         detail: stringifyPayload(toolInput),
         command,
-        paths: []
+        paths
     };
 }
 function buildOpenCodeKind(title, metadata, pattern, fallbackToolName) {
@@ -1492,18 +1545,327 @@ function buildClaudeAllowedScopeKey(request) {
             .sort();
         return normalizedPaths.length > 0 ? `file_change:${normalizedPaths.join("|")}` : null;
     }
+    if (request.kind === "tool_call") {
+        const normalizedToolName = normalizeText(request.toolName)?.toLowerCase() ?? null;
+        const normalizedPaths = request.paths
+            .map((path) => normalizeText(path))
+            .filter((path) => Boolean(path))
+            .sort();
+        if (!normalizedToolName || normalizedPaths.length === 0) {
+            return null;
+        }
+        return `tool_call:${normalizedToolName}:${normalizedPaths.join("|")}`;
+    }
     return null;
 }
-function buildClaudeActions(kind) {
+function buildClaudeActions(request) {
     const actions = [
         createAction("allow", "允许", "primary", "只允许这一次")
     ];
-    if (kind === "command" || kind === "file_change") {
+    if (buildClaudeAllowedScopeKey(request)) {
         actions.push(createAction("allow_session", "本会话默认允许", "neutral", "仅对同类操作默认放行"));
     }
     actions.push(createAction("deny", "拒绝", "danger", "阻止这次工具操作继续执行"));
     return actions;
 }
+function resolveClaudeAssistantCliAutoApprovalReason(command) {
+    const parsed = parseCodingNsAssistantCommand(command);
+    if (!parsed) {
+        return null;
+    }
+    if (parsed.mode === "help") {
+        return "CodingNS 已自动放行只读的助手帮助命令";
+    }
+    if (!isSupportedAssistantCliAction(parsed.group, parsed.action)) {
+        return null;
+    }
+    if (isReadonlyAssistantCliAction(parsed.group, parsed.action)) {
+        return "CodingNS 已自动放行只读的助手 CLI 查询命令";
+    }
+    return "CodingNS 已自动放行受控的助手 CLI 执行命令";
+}
+export function resolveClaudeSafeShellAutoApprovalReason(command) {
+    const normalized = normalizeText(command);
+    if (!normalized || containsShellControlOperator(normalized)) {
+        return null;
+    }
+    const tokens = tokenizeShellCommand(normalized);
+    if (tokens.length === 0) {
+        return null;
+    }
+    const executable = normalizeShellExecutableName(tokens[0]);
+    if (!executable) {
+        return null;
+    }
+    if (executable === "command"
+        && tokens[1] === "-v"
+        && tokens.length === 3
+        && isSafeShellLookupTarget(tokens[2])) {
+        return "CodingNS 已自动放行助手会话里的安全只读命令";
+    }
+    if (executable === "pwd" || executable === "whoami" || executable === "uname" || executable === "date") {
+        return "CodingNS 已自动放行助手会话里的安全只读命令";
+    }
+    if (executable === "ls") {
+        return "CodingNS 已自动放行助手会话里的安全只读命令";
+    }
+    if (executable === "cat") {
+        return hasReadableFileTarget(tokens.slice(1))
+            ? "CodingNS 已自动放行助手会话里的安全只读命令"
+            : null;
+    }
+    if (executable === "head" || executable === "tail" || executable === "wc" || executable === "stat" || executable === "file") {
+        return hasReadableFileTarget(tokens.slice(1))
+            ? "CodingNS 已自动放行助手会话里的安全只读命令"
+            : null;
+    }
+    if (executable === "sed") {
+        return isSafeReadonlySedCommand(tokens)
+            ? "CodingNS 已自动放行助手会话里的安全只读命令"
+            : null;
+    }
+    if (executable === "find") {
+        return isSafeReadonlyFindCommand(tokens)
+            ? "CodingNS 已自动放行助手会话里的安全只读命令"
+            : null;
+    }
+    if (executable === "rg" || executable === "grep") {
+        return "CodingNS 已自动放行助手会话里的安全只读命令";
+    }
+    if (executable === "git") {
+        return isSafeReadonlyGitCommand(tokens)
+            ? "CodingNS 已自动放行助手会话里的安全只读命令"
+            : null;
+    }
+    if (isSafeReadonlyVersionCommand(executable, tokens.slice(1))) {
+        return "CodingNS 已自动放行助手会话里的安全只读命令";
+    }
+    return null;
+}
+function parseCodingNsAssistantCommand(command) {
+    const normalized = normalizeText(command);
+    if (!normalized || containsShellControlOperator(normalized)) {
+        return null;
+    }
+    const tokens = tokenizeShellCommand(normalized);
+    const startIndex = tokens.findIndex((token, index) => token === "codingns" && tokens[index + 1] === "assistant");
+    if (startIndex < 0) {
+        return null;
+    }
+    const invocation = tokens.slice(startIndex + 2);
+    if (invocation.length === 0 || invocation[0] === "--help" || invocation[0] === "-h") {
+        return {
+            group: null,
+            action: null,
+            mode: "help"
+        };
+    }
+    if (invocation[0] === "help") {
+        return {
+            group: invocation[1] ?? null,
+            action: invocation[2] ?? null,
+            mode: "help"
+        };
+    }
+    const group = invocation[0] ?? null;
+    const actionCandidate = invocation[1];
+    const action = actionCandidate && !actionCandidate.startsWith("-")
+        ? actionCandidate
+        : null;
+    if (!action && invocation.some((token) => token === "--help" || token === "-h")) {
+        return {
+            group,
+            action: null,
+            mode: "help"
+        };
+    }
+    return {
+        group,
+        action,
+        mode: "execute"
+    };
+}
+function normalizeShellExecutableName(token) {
+    const normalized = normalizeText(token);
+    if (!normalized) {
+        return null;
+    }
+    return basename(normalized).trim().toLowerCase() || null;
+}
+function isSafeShellLookupTarget(token) {
+    const normalized = normalizeText(token);
+    return Boolean(normalized && /^[a-zA-Z0-9._+-]+$/.test(normalized));
+}
+function hasReadableFileTarget(args) {
+    return args.some((token) => {
+        const normalized = normalizeText(token);
+        return Boolean(normalized && !normalized.startsWith("-"));
+    });
+}
+function isSafeReadonlySedCommand(tokens) {
+    if (tokens.length < 4) {
+        return false;
+    }
+    let hasQuietFlag = false;
+    let hasEditableFlag = false;
+    for (const token of tokens.slice(1)) {
+        const normalized = normalizeText(token) ?? "";
+        if (normalized === "-n" || normalized === "--quiet" || normalized === "--silent") {
+            hasQuietFlag = true;
+            continue;
+        }
+        if (normalized === "-i" || normalized === "--in-place" || normalized.startsWith("-i")) {
+            hasEditableFlag = true;
+        }
+    }
+    return hasQuietFlag && !hasEditableFlag && hasReadableFileTarget(tokens.slice(1));
+}
+function isSafeReadonlyFindCommand(tokens) {
+    if (tokens.length < 2) {
+        return false;
+    }
+    const blockedFlags = new Set([
+        "-delete",
+        "-exec",
+        "-execdir",
+        "-ok",
+        "-okdir",
+        "-fls",
+        "-fprint",
+        "-fprintf"
+    ]);
+    return !tokens.some((token) => blockedFlags.has(token));
+}
+function isSafeReadonlyGitCommand(tokens) {
+    const subcommand = normalizeText(tokens[1])?.toLowerCase() ?? null;
+    if (!subcommand) {
+        return false;
+    }
+    if (subcommand === "status"
+        || subcommand === "diff"
+        || subcommand === "log"
+        || subcommand === "show"
+        || subcommand === "rev-parse"
+        || subcommand === "ls-files"
+        || subcommand === "grep") {
+        return true;
+    }
+    if (subcommand !== "branch") {
+        return false;
+    }
+    const safeBranchFlags = new Set([
+        "-a",
+        "--all",
+        "-r",
+        "--remotes",
+        "-v",
+        "-vv",
+        "--verbose",
+        "--show-current"
+    ]);
+    return tokens.slice(2).every((token) => safeBranchFlags.has(token));
+}
+function isSafeReadonlyVersionCommand(executable, args) {
+    if (!new Set(["node", "npm", "pnpm", "yarn", "bun", "python", "python3"]).has(executable)) {
+        return false;
+    }
+    if (args.length === 1 && (args[0] === "-v" || args[0] === "--version")) {
+        return true;
+    }
+    return args.length === 1 && (args[0] === "-h" || args[0] === "--help" || args[0] === "help");
+}
+function containsShellControlOperator(command) {
+    return /(^|[^\\])(?:&&|\|\||[;|><]|`|\$\()/.test(command);
+}
+function tokenizeShellCommand(command) {
+    const tokens = [];
+    const pattern = /"([^"\\]|\\.)*"|'([^'\\]|\\.)*'|`([^`\\]|\\.)*`|\S+/g;
+    for (const match of command.matchAll(pattern)) {
+        const value = match[0] ?? "";
+        if (!value) {
+            continue;
+        }
+        const quoted = value[0];
+        if ((quoted === "\"" || quoted === "'" || quoted === "`") && value[value.length - 1] === quoted) {
+            tokens.push(value.slice(1, -1));
+            continue;
+        }
+        tokens.push(value);
+    }
+    return tokens;
+}
+function isReadonlyAssistantCliAction(group, action) {
+    const readonlyActions = getSupportedAssistantCliActions(group);
+    if (!readonlyActions) {
+        return false;
+    }
+    const normalizedAction = action?.trim();
+    if (!normalizedAction) {
+        return false;
+    }
+    return readonlyActions.readonly.has(normalizedAction);
+}
+function isSupportedAssistantCliAction(group, action) {
+    const supportedActions = getSupportedAssistantCliActions(group);
+    const normalizedAction = action?.trim();
+    if (!supportedActions || !normalizedAction) {
+        return false;
+    }
+    return supportedActions.readonly.has(normalizedAction) || supportedActions.mutating.has(normalizedAction);
+}
+function getSupportedAssistantCliActions(group) {
+    const normalizedGroup = group?.trim();
+    if (!normalizedGroup) {
+        return null;
+    }
+    const supportedActionsByGroup = {
+        capabilities: {
+            readonly: new Set(["list"]),
+            mutating: new Set()
+        },
+        projects: {
+            readonly: new Set(["list", "get"]),
+            mutating: new Set()
+        },
+        sessions: {
+            readonly: new Set(["list", "get", "messages", "runtime"]),
+            mutating: new Set(["start", "send", "fork"])
+        },
+        automations: {
+            readonly: new Set(["list", "get", "runs"]),
+            mutating: new Set(["create", "cancel"])
+        },
+        sandboxes: {
+            readonly: new Set(["list"]),
+            mutating: new Set(["create", "promote", "expire", "remove"])
+        },
+        timers: {
+            readonly: new Set(["list", "get"]),
+            mutating: new Set(["create", "cancel"])
+        },
+        terminals: {
+            readonly: new Set(["list", "history"]),
+            mutating: new Set(["send", "close"])
+        },
+        "debug-targets": {
+            readonly: new Set(["compatibility-matrix", "framework-analysis", "runtime-latest", "runtimes"]),
+            mutating: new Set(["analyze", "refresh-framework-analysis", "launch-plan", "run"])
+        },
+        "debug-runtimes": {
+            readonly: new Set(["get"]),
+            mutating: new Set()
+        },
+        workspaces: {
+            readonly: new Set(["list", "browse", "management"]),
+            mutating: new Set(["mkdir", "import", "clone", "reorder", "nav-state", "remove"])
+        },
+        worktrees: {
+            readonly: new Set(["tree", "merge-preview"]),
+            mutating: new Set(["create", "merge", "cleanup"])
+        }
+    };
+    return supportedActionsByGroup[normalizedGroup] ?? null;
+}
 function stringifyPayload(value) {
     if (value === undefined) {
         return null;