@jsonstudio/rcc 0.90.367 → 0.90.429

package/vendor/llmswitch-core/dist/tools/exec-command/validator.js

@@ -1,238 +0,0 @@
-import { parseToolArgsJson } from '../args-json.js';
-import { normalizeExecCommandArgs } from './normalize.js';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const toJson = (value) => {
-    try {
-        return JSON.stringify(value ?? {});
-    }
-    catch {
-        return '{}';
-    }
-};
-const POLICY_CACHE = new Map();
-const GIT_RESET_HARD_PATTERN = /\bgit\s+reset\s+--hard(?:\s|$)/i;
-const GIT_CHECKOUT_PATTERN = /\bgit\s+checkout\b/i;
-const SHELL_SEPARATORS = new Set([';', '&&', '||', '|', '&']);
-function splitShellTokens(command) {
-    const tokens = [];
-    let current = '';
-    let quote = null;
-    let escaped = false;
-    const pushCurrent = () => {
-        if (current.length > 0) {
-            tokens.push(current);
-            current = '';
-        }
-    };
-    for (let i = 0; i < command.length; i += 1) {
-        const ch = command[i];
-        if (escaped) {
-            current += ch;
-            escaped = false;
-            continue;
-        }
-        if (ch === '\\') {
-            escaped = true;
-            continue;
-        }
-        if (quote) {
-            if (ch === quote) {
-                quote = null;
-            }
-            else {
-                current += ch;
-            }
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            quote = ch;
-            continue;
-        }
-        if (/\s/.test(ch)) {
-            pushCurrent();
-            continue;
-        }
-        if (ch === ';') {
-            pushCurrent();
-            tokens.push(';');
-            continue;
-        }
-        if (ch === '|' || ch === '&') {
-            pushCurrent();
-            const next = command[i + 1];
-            if ((ch === '|' || ch === '&') && next === ch) {
-                tokens.push(ch + next);
-                i += 1;
-            }
-            else {
-                tokens.push(ch);
-            }
-            continue;
-        }
-        current += ch;
-    }
-    pushCurrent();
-    return tokens;
-}
-function evaluateGitCheckoutScope(command) {
-    const match = GIT_CHECKOUT_PATTERN.exec(command);
-    if (!match) {
-        return null;
-    }
-    const checkoutText = command.slice(match.index);
-    const tokens = splitShellTokens(checkoutText);
-    if (tokens.length < 3 || tokens[0]?.toLowerCase() !== 'git' || tokens[1]?.toLowerCase() !== 'checkout') {
-        return {
-            reason: 'forbidden_git_checkout_scope',
-            message: 'Command blocked: git checkout is restricted to a single file path. Use `git checkout -- <file>` or `git checkout <ref> -- <file>`.'
-        };
-    }
-    const separatorIdx = tokens.findIndex((token, idx) => idx >= 2 && SHELL_SEPARATORS.has(token));
-    if (separatorIdx >= 0) {
-        return {
-            reason: 'forbidden_git_checkout_scope',
-            message: 'Command blocked: git checkout must be a standalone single-file command (no chained commands).'
-        };
-    }
-    const checkoutTokens = separatorIdx >= 0 ? tokens.slice(0, separatorIdx) : tokens;
-    const dashDashIdx = checkoutTokens.indexOf('--', 2);
-    if (dashDashIdx < 0) {
-        return {
-            reason: 'forbidden_git_checkout_scope',
-            message: 'Command blocked: git checkout is restricted to a single file path. Use `git checkout -- <file>` or `git checkout <ref> -- <file>`.'
-        };
-    }
-    const beforeDashDash = checkoutTokens.slice(2, dashDashIdx);
-    if (beforeDashDash.length > 1 || beforeDashDash.some((token) => token.startsWith('-'))) {
-        return {
-            reason: 'forbidden_git_checkout_scope',
-            message: 'Command blocked: git checkout is restricted to a single file path. Use `git checkout -- <file>` or `git checkout <ref> -- <file>`.'
-        };
-    }
-    const paths = checkoutTokens.slice(dashDashIdx + 1);
-    if (paths.length !== 1) {
-        return {
-            reason: 'forbidden_git_checkout_scope',
-            message: 'Command blocked: git checkout is restricted to a single file path. Use `git checkout -- <file>` or `git checkout <ref> -- <file>`.'
-        };
-    }
-    const path = paths[0];
-    if (!path || path === '.' || path === '/' || path === '*' || path.endsWith('/')) {
-        return {
-            reason: 'forbidden_git_checkout_scope',
-            message: 'Command blocked: git checkout is restricted to one concrete file path (directory/pathset restore is not allowed).'
-        };
-    }
-    return null;
-}
-function resolvePolicyPath(rawPath) {
-    const trimmed = rawPath.trim();
-    if (!trimmed) {
-        return '';
-    }
-    if (trimmed.startsWith('~/')) {
-        return path.join(os.homedir(), trimmed.slice(2));
-    }
-    return path.resolve(trimmed);
-}
-function loadPolicyRules(policyFile) {
-    const resolved = typeof policyFile === 'string' ? resolvePolicyPath(policyFile) : '';
-    if (!resolved) {
-        return [];
-    }
-    try {
-        const stat = fs.statSync(resolved);
-        if (!stat.isFile()) {
-            return [];
-        }
-        const cached = POLICY_CACHE.get(resolved);
-        if (cached && cached.mtimeMs === stat.mtimeMs) {
-            return cached.rules;
-        }
-        const raw = fs.readFileSync(resolved, 'utf8');
-        const parsed = raw.trim() ? JSON.parse(raw) : {};
-        const rulesNode = isRecord(parsed) && Array.isArray(parsed.rules) ? parsed.rules : [];
-        const rules = [];
-        for (const item of rulesNode) {
-            if (!isRecord(item)) {
-                continue;
-            }
-            const type = typeof item.type === 'string' ? item.type.trim().toLowerCase() : '';
-            if (type !== 'regex') {
-                continue;
-            }
-            const pattern = typeof item.pattern === 'string' ? item.pattern : '';
-            if (!pattern.trim()) {
-                continue;
-            }
-            const id = typeof item.id === 'string' && item.id.trim() ? item.id.trim() : `rule_${rules.length + 1}`;
-            const reason = typeof item.reason === 'string' && item.reason.trim()
-                ? item.reason.trim()
-                : `policy rule "${id}" blocked this command`;
-            const flagsRaw = typeof item.flags === 'string' ? item.flags.trim() : '';
-            let regex;
-            try {
-                regex = new RegExp(pattern, flagsRaw || 'i');
-            }
-            catch {
-                continue;
-            }
-            rules.push({ id, regex, reason });
-        }
-        POLICY_CACHE.set(resolved, { mtimeMs: stat.mtimeMs, rules });
-        return rules;
-    }
-    catch {
-        return [];
-    }
-}
-function detectPolicyRuleViolation(command, options) {
-    const rules = loadPolicyRules(options?.policyFile);
-    if (!rules.length) {
-        return null;
-    }
-    for (const rule of rules) {
-        if (rule.regex.test(command)) {
-            return {
-                reason: 'forbidden_exec_command_policy',
-                message: rule.reason
-            };
-        }
-    }
-    return null;
-}
-function detectPolicyViolation(command, options) {
-    if (!command || !command.trim()) {
-        return null;
-    }
-    const policyViolation = detectPolicyRuleViolation(command, options);
-    if (policyViolation) {
-        return policyViolation;
-    }
-    if (GIT_RESET_HARD_PATTERN.test(command)) {
-        return {
-            reason: 'forbidden_git_reset_hard',
-            message: 'Command blocked: `git reset --hard` is destructive. Use `git reset --mixed <ref>` or file-scoped restore commands instead.'
-        };
-    }
-    return evaluateGitCheckoutScope(command);
-}
-export function validateExecCommandArgs(argsString, rawArgs, options) {
-    const raw = typeof argsString === 'string' ? argsString : String(argsString ?? '');
-    const parsed = isRecord(rawArgs) && Object.keys(rawArgs).length > 0
-        ? rawArgs
-        : parseToolArgsJson(raw);
-    const normalized = normalizeExecCommandArgs(parsed);
-    if (normalized.ok === false) {
-        return { ok: false, reason: normalized.reason };
-    }
-    const command = typeof normalized.normalized.cmd === 'string' ? normalized.normalized.cmd : '';
-    const violation = detectPolicyViolation(command, options);
-    if (violation) {
-        return { ok: false, reason: violation.reason, message: violation.message };
-    }
-    return { ok: true, normalizedArgs: toJson(normalized.normalized) };
-}

package/vendor/llmswitch-core/dist/tools/patch-regression-capturer.d.ts

@@ -1 +0,0 @@
-export { captureApplyPatchRegression } from './apply-patch/regression-capturer.js';

package/vendor/llmswitch-core/dist/tools/patch-regression-capturer.js

@@ -1 +0,0 @@
-export { captureApplyPatchRegression } from './apply-patch/regression-capturer.js';

package/vendor/llmswitch-core/dist/tools/tool-description-utils.d.ts

@@ -1,5 +0,0 @@
-export declare function normalizeToolName(value: unknown): string;
-export declare function isShellToolName(value: unknown): boolean;
-export declare function hasApplyPatchToolDeclared(tools: unknown[] | undefined): boolean;
-export declare function buildShellDescription(toolDisplayName: string, hasApplyPatch: boolean): string;
-export declare function appendApplyPatchReminder(description: string, hasApplyPatch: boolean): string;

package/vendor/llmswitch-core/dist/tools/tool-description-utils.js

@@ -1,50 +0,0 @@
-const SHELL_TOOL_ALIASES = new Set(['shell', 'shell_command', 'exec_command', 'bash']);
-const APPLY_PATCH_NAME = 'apply_patch';
-export function normalizeToolName(value) {
-    return typeof value === 'string' ? value.trim().toLowerCase() : '';
-}
-function extractToolFunctionName(entry) {
-    if (!entry || typeof entry !== 'object') {
-        return '';
-    }
-    const fnName = typeof entry.function?.name === 'string'
-        ? entry.function.name
-        : undefined;
-    if (fnName && fnName.trim().length > 0) {
-        return fnName.trim();
-    }
-    const topName = typeof entry.name === 'string' ? entry.name : '';
-    return topName.trim();
-}
-export function isShellToolName(value) {
-    return SHELL_TOOL_ALIASES.has(normalizeToolName(value));
-}
-export function hasApplyPatchToolDeclared(tools) {
-    if (!Array.isArray(tools)) {
-        return false;
-    }
-    return tools.some((entry) => normalizeToolName(extractToolFunctionName(entry)) === APPLY_PATCH_NAME);
-}
-export function buildShellDescription(toolDisplayName, hasApplyPatch) {
-    const label = toolDisplayName && toolDisplayName.trim().length > 0
-        ? toolDisplayName.trim()
-        : 'shell';
-    const base = 'Runs a shell command and returns its output.';
-    const workdirLine = `- Always set the \`workdir\` param when using the ${label} function. Avoid using \`cd\` unless absolutely necessary.`;
-    const applyPatchLine = '- Prefer apply_patch for editing files instead of shell redirection or here-doc usage.';
-    return hasApplyPatch ? `${base}\n${workdirLine}\n${applyPatchLine}` : `${base}\n${workdirLine}`;
-}
-export function appendApplyPatchReminder(description, hasApplyPatch) {
-    if (!hasApplyPatch) {
-        return description;
-    }
-    const trimmed = description?.trim() ?? '';
-    if (!trimmed) {
-        return buildShellDescription('shell', true);
-    }
-    if (trimmed.includes('apply_patch')) {
-        return trimmed;
-    }
-    const applyPatchLine = '- Prefer apply_patch for editing files instead of shell redirection or here-doc usage.';
-    return `${trimmed}\n${applyPatchLine}`;
-}

package/vendor/llmswitch-core/dist/tools/tool-registry.d.ts

@@ -1,15 +0,0 @@
-export interface ToolValidationResult {
-    ok: boolean;
-    reason?: string;
-    message?: string;
-    warnings?: Array<Record<string, unknown>>;
-    normalizedArgs?: string;
-}
-export interface ToolValidationOptions {
-    execCommandGuard?: {
-        enabled?: boolean;
-        policyFile?: string;
-    };
-}
-export declare function getAllowedToolNames(): string[];
-export declare function validateToolCall(name: string, argsString: string, options?: ToolValidationOptions): ToolValidationResult;

package/vendor/llmswitch-core/dist/tools/tool-registry.js

@@ -1,253 +0,0 @@
-// Tool registry and validator (single source of truth)
-import { parseToolArgsJson } from './args-json.js';
-import { validateApplyPatchArgs } from './apply-patch/validator.js';
-import { captureApplyPatchRegression } from './patch-regression-capturer.js';
-import { validateExecCommandArgs } from './exec-command/validator.js';
-import { captureExecCommandRegression } from './exec-command/regression-capturer.js';
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const asString = (value) => {
-    if (typeof value === 'string' && value.trim().length > 0) {
-        return value;
-    }
-    return null;
-};
-const asStringArray = (value) => {
-    if (!Array.isArray(value)) {
-        return null;
-    }
-    const normalized = [];
-    for (const entry of value) {
-        if (typeof entry !== 'string' || entry.trim().length === 0) {
-            return null;
-        }
-        normalized.push(entry);
-    }
-    return normalized;
-};
-const readBoolean = (value) => typeof value === 'boolean' ? value : undefined;
-const readNumber = (value) => {
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        return undefined;
-    }
-    return value;
-};
-// JSON parsing/repair helpers are shared via tools/args-json.ts
-const toJson = (value) => {
-    try {
-        return JSON.stringify(value ?? {});
-    }
-    catch {
-        return '{}';
-    }
-};
-const detectForbiddenWrite = (script) => {
-    const normalized = script.toLowerCase();
-    if (!normalized) {
-        return false;
-    }
-    if (/>\s*[^\s<]/.test(normalized)) {
-        return true;
-    }
-    if (/<<</.test(normalized) || /<</.test(normalized)) {
-        return true;
-    }
-    if (/\bsed\b[^\n]*-i\b/.test(normalized)) {
-        return true;
-    }
-    if (/\bed\b[^\n]*-s\b/.test(normalized)) {
-        return true;
-    }
-    if (/\btee\b\s+/.test(normalized)) {
-        return true;
-    }
-    return false;
-};
-const isImagePath = (value) => {
-    const pathValue = asString(value);
-    if (!pathValue) {
-        return false;
-    }
-    return /\.(png|jpg|jpeg|gif|webp|bmp|svg|tiff?|ico|heic|jxl)$/i.test(pathValue);
-};
-export function getAllowedToolNames() {
-    return [
-        'shell',
-        'shell_command',
-        'bash',
-        'exec_command',
-        'apply_patch',
-        'update_plan',
-        'view_image',
-        'list_mcp_resources',
-        'read_mcp_resource',
-        'list_mcp_resource_templates'
-    ];
-}
-export function validateToolCall(name, argsString, options) {
-    const normalizedName = String(name || '').trim();
-    if (!normalizedName) {
-        return { ok: false, reason: 'empty_tool_name' };
-    }
-    const allowed = new Set(getAllowedToolNames());
-    if (!allowed.has(normalizedName)) {
-        return { ok: false, reason: 'unknown_tool' };
-    }
-    const rawArgsAny = parseToolArgsJson(typeof argsString === 'string' ? argsString : '{}');
-    switch (normalizedName) {
-        case 'exec_command': {
-            const guard = options?.execCommandGuard;
-            const validation = validateExecCommandArgs(argsString, rawArgsAny, guard && guard.enabled ? { policyFile: guard.policyFile } : undefined);
-            if (!validation.ok) {
-                const reason = validation.reason || 'unknown';
-                captureExecCommandRegression({
-                    errorType: reason,
-                    originalArgs: typeof argsString === 'string' ? argsString : String(argsString ?? ''),
-                    normalizedArgs: typeof argsString === 'string' ? argsString : String(argsString ?? ''),
-                    validationError: reason,
-                    source: 'tool-registry.validateToolCall'
-                });
-                return { ok: false, reason, message: validation.message };
-            }
-            return { ok: true, normalizedArgs: validation.normalizedArgs };
-        }
-        case 'shell_command':
-        case 'bash': {
-            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
-            const command = asString(rawArgs.command) ??
-                asString(rawArgs.cmd);
-            if (!command) {
-                return { ok: false, reason: 'missing_command' };
-            }
-            return { ok: true, normalizedArgs: toJson(rawArgs) };
-        }
-        case 'apply_patch': {
-            const validation = validateApplyPatchArgs(argsString, rawArgsAny);
-            if (!validation.ok) {
-                const reason = validation.reason || 'unknown';
-                captureApplyPatchRegression({
-                    errorType: reason,
-                    originalArgs: typeof argsString === 'string' ? argsString : String(argsString ?? ''),
-                    normalizedArgs: typeof argsString === 'string' ? argsString : String(argsString ?? ''),
-                    validationError: reason,
-                    source: 'tool-registry.validateToolCall',
-                    meta: { applyPatchToolMode: 'freeform' }
-                });
-                return { ok: false, reason };
-            }
-            return { ok: true, normalizedArgs: validation.normalizedArgs };
-        }
-        case 'shell': {
-            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
-            const rawCommand = rawArgs.command;
-            let normalizedCommand = null;
-            if (typeof rawCommand === 'string') {
-                normalizedCommand = [rawCommand];
-            }
-            else {
-                normalizedCommand = asStringArray(rawCommand);
-            }
-            if (!normalizedCommand) {
-                return { ok: false, reason: 'invalid_command' };
-            }
-            const scriptJoined = normalizedCommand.join(' ');
-            if (detectForbiddenWrite(scriptJoined)) {
-                return { ok: false, reason: 'forbidden_write_redirection' };
-            }
-            const looksBashLc = (arr) => arr.length >= 2 && arr[0] === 'bash' && arr[1] === '-lc';
-            const hasMetaChars = (script) => /[|;&]/.test(script) || script.includes('&&') || script.includes('||');
-            let finalCommand = normalizedCommand.slice();
-            if (!looksBashLc(finalCommand) && hasMetaChars(scriptJoined)) {
-                finalCommand = ['bash', '-lc', scriptJoined];
-            }
-            const shellArgs = { command: finalCommand };
-            const workdir = asString(rawArgs.workdir);
-            if (workdir) {
-                shellArgs.workdir = workdir;
-            }
-            const timeout = readNumber(rawArgs.timeout_ms);
-            if (timeout !== undefined) {
-                shellArgs.timeout_ms = timeout;
-            }
-            const escalated = readBoolean(rawArgs.with_escalated_permissions);
-            if (typeof escalated === 'boolean') {
-                shellArgs.with_escalated_permissions = escalated;
-            }
-            const justification = asString(rawArgs.justification);
-            if (justification) {
-                shellArgs.justification = justification;
-            }
-            return { ok: true, normalizedArgs: toJson(shellArgs) };
-        }
-        case 'update_plan': {
-            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
-            if (!Array.isArray(rawArgs.plan)) {
-                return { ok: false, reason: 'missing_plan' };
-            }
-            let inProgressCount = 0;
-            for (const entry of rawArgs.plan) {
-                if (isRecord(entry) && entry.status === 'in_progress') {
-                    inProgressCount += 1;
-                }
-            }
-            const warnings = [];
-            if (inProgressCount > 1) {
-                warnings.push({ kind: 'multiple_in_progress', count: inProgressCount });
-            }
-            const explanation = asString(rawArgs.explanation);
-            return {
-                ok: true,
-                warnings: warnings.length ? warnings : undefined,
-                normalizedArgs: toJson({ explanation, plan: rawArgs.plan })
-            };
-        }
-        case 'view_image': {
-            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
-            const pathValue = asString(rawArgs.path);
-            if (!pathValue || !isImagePath(pathValue)) {
-                return { ok: false, reason: 'invalid_image_path' };
-            }
-            return { ok: true, normalizedArgs: toJson({ path: pathValue }) };
-        }
-        case 'list_mcp_resources': {
-            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
-            const payload = {};
-            const server = asString(rawArgs.server);
-            if (server) {
-                payload.server = server;
-            }
-            const filter = asString(rawArgs.filter);
-            if (filter) {
-                payload.filter = filter;
-            }
-            const root = asString(rawArgs.root);
-            if (root) {
-                payload.root = root;
-            }
-            return { ok: true, normalizedArgs: toJson(payload) };
-        }
-        case 'read_mcp_resource': {
-            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
-            const server = asString(rawArgs.server);
-            const uri = asString(rawArgs.uri);
-            if (!server || !uri) {
-                return { ok: false, reason: 'missing_server_or_uri' };
-            }
-            return { ok: true, normalizedArgs: toJson({ server, uri }) };
-        }
-        case 'list_mcp_resource_templates': {
-            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
-            const payload = {};
-            const server = asString(rawArgs.server);
-            if (server) {
-                payload.server = server;
-            }
-            const cursor = asString(rawArgs.cursor);
-            if (cursor) {
-                payload.cursor = cursor;
-            }
-            return { ok: true, normalizedArgs: toJson(payload) };
-        }
-        default:
-            return { ok: false, reason: 'unknown_tool' };
-    }
-}