@tencent-ai/agent-sdk 0.3.186 → 0.3.188-dev.368febf.202606232001

package/cli/vendor/shim/safe-bin/safe-delete-common.sh

@@ -45,11 +45,115 @@ safe_delete_record_trash() {
         "$path_json" "$timestamp" >> "$CODEBUDDY_SAFE_DELETE_REPORT_PATH" 2>/dev/null || true
 }
 
+safe_delete_bulk_guard_check() {
+    [ "$#" -gt 0 ] || return 0
+    [ -n "${CODEBUDDY_SAFE_DELETE_BULK_STATE_DIR:-}" ] || return 0
+    [ -n "${CODEBUDDY_TOOL_CALL_ID:-}" ] || return 0
+    if [ -z "${CODEBUDDY_NODE_BIN:-}" ] || [ -z "${CODEBUDDY_SAFE_DELETE_BULK_GUARD:-}" ] || [ ! -f "$CODEBUDDY_SAFE_DELETE_BULK_GUARD" ]; then
+        echo "[safe-delete][SAFE_DELETE_BULK_GUARD_ERROR] msg=helper-unavailable guard=${CODEBUDDY_SAFE_DELETE_BULK_GUARD:-unset}" >&2
+        return 1
+    fi
+
+    local args=()
+    local p
+    for p in "$@"; do
+        args+=(--target "$(safe_delete_abs_path "$p")")
+    done
+    NODE_OPTIONS= "$CODEBUDDY_NODE_BIN" "$CODEBUDDY_SAFE_DELETE_BULK_GUARD" check "${args[@]}"
+}
+
 is_dir_empty() {
     local p="$1"
     [ -z "$(ls -A "$p" 2>/dev/null)" ]
 }
 
+safe_delete_normalize_path() {
+    local p="$1"
+    while [ "$p" != "/" ] && [ "${p%/}" != "$p" ]; do
+        p="${p%/}"
+    done
+    printf '%s' "$p"
+}
+
+safe_delete_to_unix_path_if_possible() {
+    local p="$1"
+    if command -v cygpath >/dev/null 2>&1; then
+        cygpath -u "$p" 2>/dev/null && return 0
+    fi
+    printf '%s' "$p"
+}
+
+safe_delete_resolve_os_tmp_dir() {
+    local tmp="${TMPDIR:-${TMP:-${TEMP:-/tmp}}}"
+    safe_delete_to_unix_path_if_possible "$tmp"
+}
+
+safe_delete_abs_path() {
+    local p="$1"
+    local abs
+    if command -v python3 >/dev/null 2>&1; then
+        abs="$(python3 -c 'import os,sys; print(os.path.abspath(sys.argv[1]))' "$p" 2>/dev/null)" && {
+            safe_delete_to_unix_path_if_possible "$abs"
+            return 0
+        }
+    elif command -v python >/dev/null 2>&1; then
+        abs="$(python -c 'import os,sys; print(os.path.abspath(sys.argv[1]))' "$p" 2>/dev/null)" && {
+            safe_delete_to_unix_path_if_possible "$abs"
+            return 0
+        }
+    fi
+    case "$p" in
+        /*|[A-Za-z]:/*) abs="$p" ;;
+        *)              abs="$PWD/$p" ;;
+    esac
+    abs="$(CDPATH= cd -P -- "$(dirname "$abs")" 2>/dev/null && printf '%s/%s' "$PWD" "$(basename "$abs")" || printf '%s' "$abs")"
+    safe_delete_to_unix_path_if_possible "$abs"
+}
+
+safe_delete_tmp_root_allowed() {
+    local root="$1"
+    [ -n "$root" ] || return 1
+    [ "$root" != "/" ] || return 1
+    [ -d "$root" ] || return 1
+    return 0
+}
+
+safe_delete_build_os_tmp_dirs() {
+    local seen="|" candidate root
+    for candidate in \
+        "$(safe_delete_resolve_os_tmp_dir)" \
+        "/tmp" \
+        "/private/tmp"
+    do
+        [ -n "$candidate" ] || continue
+        root="$(safe_delete_normalize_path "$(safe_delete_abs_path "$candidate")")"
+        safe_delete_tmp_root_allowed "$root" || continue
+        case "$seen" in
+            *"|$root|"*) ;;
+            *)
+                seen="${seen}${root}|"
+                printf '%s\n' "$root"
+                ;;
+        esac
+    done
+}
+
+SAFE_DELETE_OS_TMP_DIRS="$(safe_delete_build_os_tmp_dirs)"
+
+safe_delete_is_under_os_tmp_dir() {
+    local abs
+    abs="$(safe_delete_normalize_path "$(safe_delete_abs_path "$1")")"
+    while IFS= read -r tmp_dir; do
+        [ -n "$tmp_dir" ] || continue
+        case "$abs" in
+            "$tmp_dir"/*) return 0 ;;
+        esac
+    done <<EOF
+$SAFE_DELETE_OS_TMP_DIRS
+EOF
+    return 1
+}
+
 # ---- platform-specific trash helpers -----------------------------------------
 
 trash_darwin() {
@@ -260,11 +364,8 @@ trash_one() {
 
 try_trash() {
     local p="$1"
-    local abs="$p"
-    case "$abs" in
-        /*|[A-Za-z]:/*) ;;
-        *)              abs="$PWD/$abs" ;;
-    esac
+    local abs
+    abs="$(safe_delete_abs_path "$p")"
     if trash_one "$p"; then
         safe_delete_record_trash "$abs"
         return 0
@@ -329,6 +430,7 @@ safe_delete_rm() {
     fi
 
     local _exit=0
+    local trash_targets=()
     local p
     for p in "${targets[@]}"; do
         if [ -e "$p" ] || [ -L "$p" ]; then
@@ -344,9 +446,7 @@ safe_delete_rm() {
                     continue
                 fi
             fi
-            if ! try_trash "$p"; then
-                _exit=1
-            fi
+            trash_targets+=("$p")
         elif $force; then
             # -f: silently skip non-existent files (match real rm behavior)
             :
@@ -356,6 +456,22 @@ safe_delete_rm() {
             _exit=1
         fi
     done
+    if ! safe_delete_bulk_guard_check "${trash_targets[@]}"; then
+        return 1
+    fi
+    for p in "${trash_targets[@]}"; do
+        if safe_delete_is_under_os_tmp_dir "$p"; then
+            local native_args=()
+            $force && native_args+=("-f")
+            $recursive && native_args+=("-r")
+            $allow_dir && native_args+=("-d")
+            if ! "$REAL_RM" "${native_args[@]}" -- "$p"; then
+                _exit=1
+            fi
+        elif ! try_trash "$p"; then
+            _exit=1
+        fi
+    done
     return $_exit
 }
 
@@ -390,6 +506,14 @@ safe_delete_unlink() {
         return 1
     fi
 
+    if ! safe_delete_bulk_guard_check "$target"; then
+        return 1
+    fi
+    if safe_delete_is_under_os_tmp_dir "$target"; then
+        "$REAL_UNLINK" -- "$target"
+        return $?
+    fi
+
     try_trash "$target"
     return $?
 }
@@ -427,6 +551,7 @@ safe_delete_rmdir() {
     fi
 
     local _exit=0
+    local trash_targets=()
     local p
     for p in "${targets[@]}"; do
         if [ ! -e "$p" ] && [ ! -L "$p" ]; then
@@ -444,7 +569,17 @@ safe_delete_rmdir() {
             _exit=1
             continue
         fi
-        if ! try_trash "$p"; then
+        trash_targets+=("$p")
+    done
+    if ! safe_delete_bulk_guard_check "${trash_targets[@]}"; then
+        return 1
+    fi
+    for p in "${trash_targets[@]}"; do
+        if safe_delete_is_under_os_tmp_dir "$p"; then
+            if ! "$REAL_RMDIR" -- "$p"; then
+                _exit=1
+            fi
+        elif ! try_trash "$p"; then
             _exit=1
         fi
     done

package/cli/vendor/shim/safe-delete-bulk-guard.cjs

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const CONFIRM_MARKER = '[safe-delete][SAFE_DELETE_BULK_CONFIRM_REQUIRED]';
+const REJECTED_MARKER = '[safe-delete][SAFE_DELETE_BULK_REJECTED]';
+const ERROR_MARKER = '[safe-delete][SAFE_DELETE_BULK_GUARD_ERROR]';
+const DEFAULT_THRESHOLD = 20;
+const LOCK_TIMEOUT_MS = 2000;
+const STALE_LOCK_MS = 5 * 60 * 1000;
+const TURN_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const TARGET_SAMPLE_LIMIT = 5;
+const DISPLAY_COUNT_LIMIT = 9999;
+
+class GuardError extends Error {}
+
+function fail(message) {
+    throw new GuardError(message);
+}
+
+function parseArgs(argv) {
+    const command = argv[2];
+    const targets = [];
+    let scope;
+    for (let i = 3; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--target') {
+            const target = argv[++i];
+            if (!target) fail('missing --target value');
+            targets.push(target);
+        } else if (arg === '--scope') {
+            scope = argv[++i];
+            if (!scope) fail('missing --scope value');
+        } else {
+            fail(`unknown argument: ${arg}`);
+        }
+    }
+    return { command, targets, scope };
+}
+
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) fail(`${name} is not set`);
+    return value;
+}
+
+function normalizeThreshold(value) {
+    const raw = value === undefined || value === null || value === '' ? DEFAULT_THRESHOLD : value;
+    const threshold = Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(threshold) || threshold <= 0) fail(`invalid threshold: ${value}`);
+    return threshold;
+}
+
+function createSafeDeleteBulkGuardContext(input) {
+    if (!input || !input.stateRoot || !input.sessionId || !input.toolCallId) {
+        fail('missing bulk guard context');
+    }
+    const threshold = normalizeThreshold(input.threshold);
+    const sessionId = input.sessionId;
+    const conversationRequestId = input.conversationRequestId;
+    const sessionHash = crypto.createHash('sha256').update(sessionId).digest('hex');
+    const sessionDir = path.join(input.stateRoot, sessionHash);
+    return {
+        stateRoot: input.stateRoot,
+        sessionId,
+        toolCallId: input.toolCallId,
+        requestId: conversationRequestId || input.toolCallId,
+        threshold,
+        conversationRequestId,
+        sessionHash,
+        sessionDir,
+        statePath: path.join(sessionDir, 'state.json'),
+    };
+}
+
+function getContext() {
+    return createSafeDeleteBulkGuardContext({
+        stateRoot: requireEnv('CODEBUDDY_SAFE_DELETE_BULK_STATE_DIR'),
+        sessionId: requireEnv('CODEBUDDY_SESSION_ID'),
+        toolCallId: requireEnv('CODEBUDDY_TOOL_CALL_ID'),
+        conversationRequestId: process.env.CODEBUDDY_CONVERSATION_REQUEST_ID,
+        threshold: process.env.CODEBUDDY_SAFE_DELETE_BULK_THRESHOLD || DEFAULT_THRESHOLD,
+    });
+}
+
+function defaultState() {
+    return { requests: {}, toolApprovals: {}, requestRejections: {} };
+}
+
+function normalizeState(parsed) {
+    if (!parsed || typeof parsed !== 'object') return defaultState();
+    return {
+        requests: parsed.requests && typeof parsed.requests === 'object' ? parsed.requests : {},
+        toolApprovals: parsed.toolApprovals && typeof parsed.toolApprovals === 'object' ? parsed.toolApprovals : {},
+        requestRejections: parsed.requestRejections && typeof parsed.requestRejections === 'object' ? parsed.requestRejections : {},
+    };
+}
+
+function readState(statePath) {
+    try {
+        return normalizeState(JSON.parse(fs.readFileSync(statePath, 'utf-8')));
+    } catch (error) {
+        if (error && error.code === 'ENOENT') return defaultState();
+        fail(`failed to read state: ${error && error.message ? error.message : String(error)}`);
+    }
+}
+
+function writeState(statePath, state) {
+    const tmpPath = `${statePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(state)}\n`, 'utf-8');
+    fs.renameSync(tmpPath, statePath);
+}
+
+function normalizeRequest(request, now) {
+    if (!request || typeof request !== 'object') return { count: 0, updatedAt: now };
+    return {
+        count: Number.isFinite(request.count) ? request.count : 0,
+        updatedAt: Number.isFinite(request.updatedAt) ? request.updatedAt : now,
+    };
+}
+
+function normalizeToolApproval(approval, now) {
+    if (!approval || typeof approval !== 'object') return { approved: false, updatedAt: now };
+    return {
+        approved: approval.approved === true,
+        updatedAt: Number.isFinite(approval.updatedAt) ? approval.updatedAt : now,
+    };
+}
+
+function normalizeRequestRejection(rejection, now) {
+    if (!rejection || typeof rejection !== 'object') {
+        return { rejected: false, updatedAt: now };
+    }
+    const targets = Array.isArray(rejection.targets)
+        ? rejection.targets.filter(target => typeof target === 'string').slice(0, TARGET_SAMPLE_LIMIT)
+        : [];
+    return {
+        rejected: rejection.rejected === true,
+        updatedAt: Number.isFinite(rejection.updatedAt) ? rejection.updatedAt : now,
+        count: Number.isFinite(rejection.count) ? rejection.count : 0,
+        threshold: Number.isFinite(rejection.threshold) ? rejection.threshold : DEFAULT_THRESHOLD,
+        targets,
+        targetCount: Number.isFinite(rejection.targetCount) ? rejection.targetCount : targets.length,
+    };
+}
+
+function pruneExpired(state, now) {
+    let changed = false;
+    const nextRequests = {};
+    for (const [requestId, rawRequest] of Object.entries(state.requests)) {
+        const request = normalizeRequest(rawRequest, now);
+        if (now - request.updatedAt > TURN_STATE_TTL_MS) {
+            changed = true;
+            continue;
+        }
+        nextRequests[requestId] = request;
+        if (
+            !rawRequest
+            || typeof rawRequest !== 'object'
+            || rawRequest.count !== request.count
+            || rawRequest.updatedAt !== request.updatedAt
+        ) {
+            changed = true;
+        }
+    }
+    if (changed) state.requests = nextRequests;
+
+    const nextToolApprovals = {};
+    for (const [toolCallId, rawApproval] of Object.entries(state.toolApprovals)) {
+        const approval = normalizeToolApproval(rawApproval, now);
+        if (now - approval.updatedAt > TURN_STATE_TTL_MS) {
+            changed = true;
+            continue;
+        }
+        nextToolApprovals[toolCallId] = approval;
+        if (
+            !rawApproval
+            || typeof rawApproval !== 'object'
+            || rawApproval.approved !== approval.approved
+            || rawApproval.updatedAt !== approval.updatedAt
+        ) {
+            changed = true;
+        }
+    }
+    if (changed) state.toolApprovals = nextToolApprovals;
+
+    const nextRequestRejections = {};
+    for (const [requestId, rawRejection] of Object.entries(state.requestRejections || {})) {
+        const rejection = normalizeRequestRejection(rawRejection, now);
+        if (now - rejection.updatedAt > TURN_STATE_TTL_MS) {
+            changed = true;
+            continue;
+        }
+        if (rejection.rejected) {
+            nextRequestRejections[requestId] = rejection;
+        }
+        if (
+            !rawRejection
+            || typeof rawRejection !== 'object'
+            || rawRejection.rejected !== rejection.rejected
+            || rawRejection.updatedAt !== rejection.updatedAt
+            || rawRejection.count !== rejection.count
+            || rawRejection.threshold !== rejection.threshold
+            || rawRejection.targetCount !== rejection.targetCount
+        ) {
+            changed = true;
+        }
+    }
+    if (changed) state.requestRejections = nextRequestRejections;
+    return changed;
+}
+
+function sleepMs(ms) {
+    try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    } catch (_) {
+        const end = Date.now() + ms;
+        while (Date.now() < end) {
+            // fallback for constrained Node runtimes
+        }
+    }
+}
+
+function removeStaleLock(lockDir) {
+    try {
+        const stat = fs.statSync(lockDir);
+        if (!stat.isDirectory() || Date.now() - stat.mtimeMs <= STALE_LOCK_MS) return false;
+        fs.rmSync(lockDir, { recursive: true, force: true });
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+function withLock(context, fn) {
+    fs.mkdirSync(context.sessionDir, { recursive: true });
+    const lockDir = path.join(context.sessionDir, '.lock');
+    const started = Date.now();
+    for (;;) {
+        try {
+            fs.mkdirSync(lockDir);
+            break;
+        } catch (error) {
+            if (!error || error.code !== 'EEXIST') fail(`failed to acquire lock: ${error && error.message ? error.message : String(error)}`);
+            if (removeStaleLock(lockDir)) continue;
+            if (Date.now() - started > LOCK_TIMEOUT_MS) fail('state lock timeout');
+            sleepMs(25);
+        }
+    }
+    try {
+        return fn(context.statePath);
+    } finally {
+        try { fs.rmdirSync(lockDir); } catch (_) { /* best effort */ }
+    }
+}
+
+function normalizeTargetPath(target) {
+    if (process.platform !== 'win32' || typeof target !== 'string') return target;
+    if (/^[A-Za-z]:[\\/]/.test(target)) return target;
+    const msysMatch = target.match(/^\/([A-Za-z])(?:\/(.*))?$/);
+    if (!msysMatch) return target;
+    const drive = msysMatch[1].toUpperCase();
+    const rest = (msysMatch[2] || '').replace(/\//g, '\\');
+    return rest ? `${drive}:\\${rest}` : `${drive}:\\`;
+}
+
+function countTarget(target, remaining) {
+    if (remaining <= 0) return 0;
+    target = normalizeTargetPath(target);
+    let stat;
+    try {
+        stat = fs.lstatSync(target);
+    } catch (error) {
+        if (error && error.code === 'ENOENT') return 0;
+        fail(`failed to stat target: ${target}`);
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()) return 1;
+
+    let dir;
+    try {
+        dir = fs.opendirSync(target);
+    } catch (_) {
+        fail(`failed to read directory: ${target}`);
+    }
+    let count = 0;
+    try {
+        for (;;) {
+            if (count >= remaining) break;
+            const entry = dir.readSync();
+            if (!entry) break;
+            if (entry.isDirectory() && !entry.isSymbolicLink()) {
+                count += countTarget(path.join(target, entry.name), remaining - count);
+            } else {
+                count += 1;
+            }
+        }
+    } finally {
+        try { dir.closeSync(); } catch (_) { /* best effort */ }
+    }
+    return count;
+}
+
+function countTargets(targets, limit) {
+    let count = 0;
+    for (const target of targets) {
+        if (count >= limit) break;
+        count += countTarget(target, limit - count);
+    }
+    return count;
+}
+
+function checkSafeDeleteBulkGuard(context, targets) {
+    if (!targets || targets.length === 0) fail('check requires at least one target');
+    let decision = { kind: 'allow' };
+    withLock(context, statePath => {
+        const now = Date.now();
+        const state = readState(statePath);
+        const pruned = pruneExpired(state, now);
+        const rejection = normalizeRequestRejection(state.requestRejections && state.requestRejections[context.requestId], now);
+        if (rejection.rejected) {
+            decision = {
+                kind: 'rejected',
+                payload: {
+                    count: rejection.count,
+                    threshold: rejection.threshold,
+                    scope: 'turn',
+                    targets: rejection.targets,
+                    targetCount: rejection.targetCount,
+                },
+            };
+            if (pruned) writeState(statePath, state);
+            return;
+        }
+        const request = normalizeRequest(state.requests[context.requestId], now);
+        const approval = normalizeToolApproval(state.toolApprovals[context.toolCallId], now);
+        const deleteCount = countTargets(targets, DISPLAY_COUNT_LIMIT);
+        if (deleteCount === 0) {
+            if (pruned) writeState(statePath, state);
+            return;
+        }
+        const totalCount = request.count + deleteCount;
+        if (approval.approved) {
+            state.requests[context.requestId] = { count: totalCount, updatedAt: now };
+            writeState(statePath, state);
+            return;
+        }
+        if (totalCount >= context.threshold) {
+            decision = {
+                kind: 'confirmRequired',
+                payload: {
+                    count: totalCount,
+                    threshold: context.threshold,
+                    scope: 'turn',
+                    targets: targets.slice(0, TARGET_SAMPLE_LIMIT),
+                    targetCount: targets.length,
+                },
+            };
+            if (pruned) writeState(statePath, state);
+            return;
+        }
+        state.requests[context.requestId] = { count: totalCount, updatedAt: now };
+        writeState(statePath, state);
+    });
+    return decision;
+}
+
+function handleCheck(args) {
+    if (args.targets.length === 0) fail('check requires at least one --target');
+    const decision = checkSafeDeleteBulkGuard(getContext(), args.targets);
+    if (decision.kind === 'confirmRequired') {
+        process.stderr.write(`${CONFIRM_MARKER} ${JSON.stringify(decision.payload)}\n`);
+        process.exit(2);
+    }
+    if (decision.kind === 'rejected') {
+        process.stderr.write(`${REJECTED_MARKER} ${JSON.stringify(decision.payload)}\n`);
+        process.exit(3);
+    }
+}
+
+function approveSafeDeleteBulkGuard(context, scope) {
+    if (scope && scope !== 'turn') fail('approve requires scope turn');
+    withLock(context, statePath => {
+        const now = Date.now();
+        const state = readState(statePath);
+        pruneExpired(state, now);
+        state.toolApprovals[context.toolCallId] = { approved: true, updatedAt: now };
+        writeState(statePath, state);
+    });
+}
+
+function rejectSafeDeleteBulkGuard(context, payload) {
+    const normalized = normalizeRequestRejection({ ...payload, rejected: true }, Date.now());
+    withLock(context, statePath => {
+        const now = Date.now();
+        const state = readState(statePath);
+        pruneExpired(state, now);
+        state.requests[context.requestId] = {
+            count: normalized.count,
+            updatedAt: now,
+        };
+        state.requestRejections[context.requestId] = {
+            rejected: true,
+            updatedAt: now,
+            count: normalized.count,
+            threshold: normalized.threshold,
+            targets: normalized.targets,
+            targetCount: normalized.targetCount,
+        };
+        delete state.toolApprovals[context.toolCallId];
+        writeState(statePath, state);
+    });
+}
+
+function handleApprove(args) {
+    if (args.scope && args.scope !== 'turn') fail('approve requires scope turn');
+    approveSafeDeleteBulkGuard(getContext(), args.scope);
+}
+
+function main() {
+    const args = parseArgs(process.argv);
+    if (args.command === 'check') return handleCheck(args);
+    if (args.command === 'approve') return handleApprove(args);
+    fail(`unknown command: ${args.command || '(empty)'}`);
+}
+
+module.exports = {
+    approveSafeDeleteBulkGuard,
+    checkSafeDeleteBulkGuard,
+    createSafeDeleteBulkGuardContext,
+    rejectSafeDeleteBulkGuard,
+    DEFAULT_THRESHOLD,
+    CONFIRM_MARKER,
+    REJECTED_MARKER,
+    ERROR_MARKER,
+};
+
+if (require.main === module) {
+    try {
+        main();
+    } catch (error) {
+        process.stderr.write(`${ERROR_MARKER} ${error && error.message ? error.message : String(error)}\n`);
+        process.exit(1);
+    }
+}