@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/tools/exec-command/validator.js

@@ -0,0 +1,238 @@
+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/@jsonstudio/llms/dist/tools/patch-regression-capturer.d.ts

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

package/vendor/@jsonstudio/llms/dist/tools/patch-regression-capturer.js

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

package/vendor/@jsonstudio/llms/dist/tools/tool-description-utils.d.ts

@@ -0,0 +1,5 @@
+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/@jsonstudio/llms/dist/tools/tool-description-utils.js

@@ -0,0 +1,50 @@
+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/@jsonstudio/llms/dist/tools/tool-registry.d.ts

@@ -0,0 +1,15 @@
+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/@jsonstudio/llms/dist/tools/tool-registry.js

@@ -0,0 +1,253 @@
+// 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' };
+    }
+}