@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/tools/args-json.js

@@ -0,0 +1,204 @@
+// Shared JSON argument parsing helpers.
+// Goal: tolerate common markup artifacts injected by upstream providers (e.g. <arg_key>/<arg_value>),
+// while keeping behavior deterministic and side-effect free.
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const stripXmlLikeTags = (input) => {
+    try {
+        return String(input || '').replace(/<[^>]+>/g, '');
+    }
+    catch {
+        return input;
+    }
+};
+const stripArgKeyArtifacts = (input) => {
+    try {
+        return String(input || '')
+            .replace(/<\/?\s*tool_call[^>]*>/gi, '')
+            .replace(/<\/?\s*arg_key\s*>/gi, '')
+            .replace(/<\/?\s*arg_value\s*>/gi, '');
+    }
+    catch {
+        return input;
+    }
+};
+const repairArgKeyArtifactsInRawJson = (input) => {
+    try {
+        let out = String(input || '');
+        if (!out.includes('<arg_key') && !out.includes('<arg_value') && !out.includes('</arg_key') && !out.includes('</arg_value')) {
+            return out;
+        }
+        // Repair patterns like: "file</arg_key><arg_value>a.ts" -> "file":"a.ts"
+        out = out.replace(/"([^"]+?)\s*<\/?\s*arg_key\s*>\s*<\/?\s*arg_value\s*>([^"]*?)"/gi, '"$1":"$2"');
+        // Strip remaining tag artifacts after pair repair.
+        out = stripArgKeyArtifacts(out);
+        return out;
+    }
+    catch {
+        return input;
+    }
+};
+const normalizeObjectKey = (rawKey) => {
+    const cleaned = stripXmlLikeTags(stripArgKeyArtifacts(rawKey)).trim();
+    if (!cleaned)
+        return rawKey;
+    return cleaned;
+};
+const coercePrimitive = (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '';
+    if (/^(true|false)$/i.test(trimmed))
+        return /^true$/i.test(trimmed);
+    if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+        return Number(trimmed);
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return trimmed;
+};
+const extractInjectedArgPairs = (raw) => {
+    const delimiter = '</arg_key><arg_value>';
+    if (typeof raw !== 'string' || !raw.includes(delimiter))
+        return null;
+    const parts = raw.split(delimiter);
+    if (parts.length < 2)
+        return null;
+    const looksLikeKey = (s) => /^[A-Za-z_][A-Za-z0-9_-]*$/.test(s.trim());
+    const pairs = [];
+    let baseValue = parts[0] ?? '';
+    if (parts.length === 2) {
+        const k = (parts[0] ?? '').trim();
+        const v = (parts[1] ?? '').trim();
+        if (looksLikeKey(k) && v.length > 0) {
+            baseValue = '';
+            pairs.push({ key: k, value: coercePrimitive(v) });
+        }
+        return pairs.length ? { baseValue, pairs } : null;
+    }
+    for (let i = 1; i + 1 < parts.length; i += 2) {
+        const key = (parts[i] ?? '').trim();
+        const rawValue = (parts[i + 1] ?? '').trim();
+        if (!looksLikeKey(key)) {
+            continue;
+        }
+        if (rawValue.length === 0) {
+            continue;
+        }
+        pairs.push({ key, value: coercePrimitive(rawValue) });
+    }
+    if (!pairs.length)
+        return null;
+    return { baseValue, pairs };
+};
+const repairArgKeyArtifactsInKeys = (value) => {
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            for (const entry of node)
+                visit(entry);
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        const keys = Object.keys(node);
+        for (const key of keys) {
+            const normalizedKey = normalizeObjectKey(key);
+            if (normalizedKey !== key && normalizedKey.trim()) {
+                if (!Object.prototype.hasOwnProperty.call(node, normalizedKey)) {
+                    node[normalizedKey] = node[key];
+                }
+                delete node[key];
+            }
+        }
+        for (const v of Object.values(node))
+            visit(v);
+    };
+    visit(value);
+};
+const repairArgKeyArtifactsInObject = (value) => {
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            for (const entry of node)
+                visit(entry);
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        for (const [k, v] of Object.entries(node)) {
+            if (typeof v === 'string') {
+                const injected = extractInjectedArgPairs(v);
+                if (injected) {
+                    if (injected.baseValue !== '') {
+                        node[k] = injected.baseValue;
+                    }
+                    for (const pair of injected.pairs) {
+                        if (!Object.prototype.hasOwnProperty.call(node, pair.key)) {
+                            node[pair.key] = pair.value;
+                        }
+                    }
+                }
+            }
+            visit(node[k]);
+        }
+    };
+    visit(value);
+};
+export function parseToolArgsJson(input) {
+    const raw = typeof input === 'string' ? input : '';
+    if (!raw.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        repairArgKeyArtifactsInKeys(parsed);
+        repairArgKeyArtifactsInObject(parsed);
+        return parsed;
+    }
+    catch {
+        // attempt raw string repair for arg_key/arg_value artifacts
+        try {
+            const repairedRaw = repairArgKeyArtifactsInRawJson(raw).trim();
+            if (repairedRaw && repairedRaw !== raw) {
+                const parsed = JSON.parse(repairedRaw);
+                repairArgKeyArtifactsInKeys(parsed);
+                repairArgKeyArtifactsInObject(parsed);
+                return parsed;
+            }
+        }
+        catch {
+            // continue
+        }
+        // try stripping common tool-call markup artifacts and parsing again
+        try {
+            const stripped = stripArgKeyArtifacts(raw).trim();
+            if (stripped && stripped !== raw) {
+                const parsed = JSON.parse(stripped);
+                repairArgKeyArtifactsInKeys(parsed);
+                repairArgKeyArtifactsInObject(parsed);
+                return parsed;
+            }
+        }
+        catch {
+            // continue
+        }
+        // attempt to parse the first JSON container substring
+        try {
+            const candidate = raw.match(/\{[\s\S]*\}|\[[\s\S]*\]/)?.[0];
+            if (candidate) {
+                const strippedCandidate = stripArgKeyArtifacts(candidate).trim();
+                const parsed = JSON.parse(strippedCandidate);
+                repairArgKeyArtifactsInKeys(parsed);
+                repairArgKeyArtifactsInObject(parsed);
+                return parsed;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return {};
+    }
+}

package/vendor/llmswitch-core/dist/tools/exec-command/normalize.d.ts

@@ -0,0 +1,17 @@
+type UnknownRecord = Record<string, unknown>;
+export type ExecCommandNormalizeResult = {
+    ok: true;
+    normalized: UnknownRecord;
+} | {
+    ok: false;
+    reason: 'missing_cmd';
+    normalized: UnknownRecord;
+};
+/**
+ * Normalize Codex CLI exec_command arguments (shape fixes only):
+ * - accept cmd/command/toon as sources for cmd
+ * - drop "toon" (must never be exposed to client)
+ * - repair common `find -exec ... ;` meta issues in cmd
+ */
+export declare function normalizeExecCommandArgs(args: unknown): ExecCommandNormalizeResult;
+export {};

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

@@ -0,0 +1,116 @@
+import { repairFindMeta } from '../../conversion/shared/tooling.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const asNonEmptyString = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+};
+const asPrimitiveString = (value) => {
+    if (typeof value === 'string')
+        return asNonEmptyString(value);
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    if (typeof value === 'boolean')
+        return String(value);
+    return undefined;
+};
+const asFiniteNumber = (value) => {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return undefined;
+    return value;
+};
+const asBoolean = (value) => {
+    if (typeof value !== 'boolean')
+        return undefined;
+    return value;
+};
+const asStringArray = (value) => {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = [];
+    for (const entry of value) {
+        if (typeof entry === 'string') {
+            out.push(entry);
+            continue;
+        }
+        if (entry == null)
+            continue;
+        out.push(String(entry));
+    }
+    return out.length ? out : undefined;
+};
+/**
+ * Normalize Codex CLI exec_command arguments (shape fixes only):
+ * - accept cmd/command/toon as sources for cmd
+ * - drop "toon" (must never be exposed to client)
+ * - repair common `find -exec ... ;` meta issues in cmd
+ */
+export function normalizeExecCommandArgs(args) {
+    const base = isRecord(args) ? { ...args } : {};
+    const cmdCandidate = asPrimitiveString(base.cmd) ??
+        asPrimitiveString(base.command) ??
+        asPrimitiveString(base.toon) ??
+        asPrimitiveString(base.script) ??
+        (() => {
+            const arr = asStringArray(base.command) ?? asStringArray(base.cmd);
+            return arr ? arr.join(' ') : undefined;
+        })();
+    // Always drop toon from outward-facing args (even if used as cmd source).
+    try {
+        if (Object.prototype.hasOwnProperty.call(base, 'toon')) {
+            delete base.toon;
+        }
+    }
+    catch {
+        // ignore
+    }
+    if (!cmdCandidate) {
+        // Keep captured samples free of hidden TOON payloads.
+        try {
+            if (Object.prototype.hasOwnProperty.call(base, 'toon')) {
+                delete base.toon;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return { ok: false, reason: 'missing_cmd', normalized: base };
+    }
+    const fixedCmd = repairFindMeta(cmdCandidate);
+    const normalized = { cmd: fixedCmd };
+    const workdir = asNonEmptyString(base.workdir) ??
+        asNonEmptyString(base.cwd) ??
+        asNonEmptyString(base.workDir);
+    if (workdir)
+        normalized.workdir = workdir;
+    const login = asBoolean(base.login);
+    if (login !== undefined)
+        normalized.login = login;
+    const tty = asBoolean(base.tty);
+    if (tty !== undefined)
+        normalized.tty = tty;
+    const timeoutMs = asFiniteNumber(base.timeout_ms) ??
+        asFiniteNumber(base.timeoutMs);
+    if (timeoutMs !== undefined)
+        normalized.timeout_ms = timeoutMs;
+    const shell = asNonEmptyString(base.shell);
+    if (shell)
+        normalized.shell = shell;
+    const sandboxPermissions = asNonEmptyString(base.sandbox_permissions) ??
+        (asBoolean(base.with_escalated_permissions) ? 'require_escalated' : undefined);
+    if (sandboxPermissions)
+        normalized.sandbox_permissions = sandboxPermissions;
+    const justification = asNonEmptyString(base.justification);
+    if (justification)
+        normalized.justification = justification;
+    const maxOutput = asFiniteNumber(base.max_output_tokens) ?? asFiniteNumber(base.max_tokens);
+    if (maxOutput !== undefined)
+        normalized.max_output_tokens = maxOutput;
+    const yieldTime = asFiniteNumber(base.yield_time_ms) ??
+        asFiniteNumber(base.yield_ms) ??
+        asFiniteNumber(base.wait_ms);
+    if (yieldTime !== undefined)
+        normalized.yield_time_ms = yieldTime;
+    return { ok: true, normalized };
+}

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

@@ -0,0 +1,11 @@
+interface RegressionSample {
+    id: string;
+    timestamp: string;
+    errorType: string;
+    originalArgs: string;
+    normalizedArgs?: string;
+    validationError?: string;
+    source?: string;
+}
+export declare function captureExecCommandRegression(sample: Omit<RegressionSample, 'id' | 'timestamp'>): void;
+export {};

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

@@ -0,0 +1,144 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createHash } from 'crypto';
+/**
+ * Captures exec_command validation regressions into a golden samples structure.
+ *
+ * Trigger: exec_command validation failure (shape/JSON/required fields)
+ *
+ * Default destination:
+ *   ~/.routecodex/golden_samples/ci-regression/exec_command/<error-type>/
+ *
+ * Optional repo destination (explicit opt-in):
+ *   ROUTECODEX_EXEC_COMMAND_REGRESSION_TO_REPO=1
+ *   → <repoRoot>/samples/ci-goldens/_regressions/exec_command/<error-type>/
+ *
+ * Explicit override:
+ *   ROUTECODEX_EXEC_COMMAND_REGRESSION_DIR=/abs/path
+ *
+ * Note: we intentionally redact obvious secrets from captured payloads.
+ */
+const MAX_SAMPLES_PER_TYPE = 50;
+function detectRepoRootFromCwd() {
+    try {
+        let dir = process.cwd();
+        for (let i = 0; i < 12; i += 1) {
+            const marker = path.join(dir, 'samples', 'ci-goldens');
+            const pkg = path.join(dir, 'package.json');
+            if (fs.existsSync(marker) && fs.existsSync(pkg)) {
+                try {
+                    const raw = fs.readFileSync(pkg, 'utf-8');
+                    const json = JSON.parse(raw);
+                    if (json && typeof json === 'object' && String(json.name || '') === 'routecodex') {
+                        return dir;
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function resolveSamplesRoot() {
+    const explicit = String(process?.env?.ROUTECODEX_EXEC_COMMAND_REGRESSION_DIR || '').trim();
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    const toRepo = String(process?.env?.ROUTECODEX_EXEC_COMMAND_REGRESSION_TO_REPO || '').trim() === '1';
+    if (toRepo) {
+        const repoRoot = detectRepoRootFromCwd();
+        if (repoRoot) {
+            return path.join(repoRoot, 'samples', 'ci-goldens', '_regressions', 'exec_command');
+        }
+    }
+    return path.join(os.homedir(), '.routecodex', 'golden_samples', 'ci-regression', 'exec_command');
+}
+function stableSampleId(sample) {
+    const key = `${String(sample.errorType || 'unknown')}:` +
+        `${String(sample.originalArgs ?? '')}:` +
+        `${String(sample.normalizedArgs ?? '')}:` +
+        `${String(sample.validationError ?? '')}`;
+    return createHash('sha1').update(key).digest('hex').slice(0, 16);
+}
+function redactSecrets(text) {
+    if (!text)
+        return text;
+    let next = text;
+    // Common API key formats (best-effort).
+    next = next.replace(/\bsk-[A-Za-z0-9_-]{10,}\b/g, 'sk-<REDACTED>');
+    next = next.replace(/\bcr_[A-Za-z0-9]{20,}\b/g, 'cr_<REDACTED>');
+    next = next.replace(/\bAIza[0-9A-Za-z_-]{20,}\b/g, 'AIza<REDACTED>');
+    // Authorization headers.
+    next = next.replace(/(authorization"?\s*:\s*"?bearer\s+)[^"]+/gi, '$1<REDACTED>');
+    next = next.replace(/(authorization:\s*bearer\s+)[^\s]+/gi, '$1<REDACTED>');
+    // Shell exports of *_KEY/*_TOKEN/*_SECRET.
+    next = next.replace(/(\bexport\s+[A-Z0-9_]*(?:KEY|TOKEN|SECRET)[A-Z0-9_]*=)[^\s'"]+/gi, '$1<REDACTED>');
+    return next;
+}
+function sanitizeArgs(raw) {
+    const trimmed = String(raw || '');
+    if (!trimmed)
+        return trimmed;
+    // If it's JSON, redact known sensitive fields (cmd) aggressively.
+    try {
+        const obj = JSON.parse(trimmed);
+        if (obj && typeof obj === 'object') {
+            const cloned = Array.isArray(obj) ? obj.slice() : { ...obj };
+            if (typeof cloned.cmd === 'string') {
+                const cmdText = String(cloned.cmd);
+                cloned.cmd = redactSecrets(cmdText).slice(0, 500);
+            }
+            return redactSecrets(JSON.stringify(cloned, null, 2));
+        }
+    }
+    catch {
+        // ignore JSON parse errors
+    }
+    return redactSecrets(trimmed);
+}
+export function captureExecCommandRegression(sample) {
+    try {
+        const root = resolveSamplesRoot();
+        const safeType = String(sample.errorType || 'unknown').replace(/[^a-z0-9-]/gi, '_');
+        const typeDir = path.join(root, safeType);
+        if (!fs.existsSync(typeDir)) {
+            fs.mkdirSync(typeDir, { recursive: true });
+        }
+        try {
+            const existing = fs.readdirSync(typeDir).filter((f) => f.endsWith('.json'));
+            if (existing.length >= MAX_SAMPLES_PER_TYPE)
+                return;
+        }
+        catch {
+            // ignore
+        }
+        const sanitized = {
+            ...sample,
+            originalArgs: sanitizeArgs(sample.originalArgs),
+            normalizedArgs: typeof sample.normalizedArgs === 'string' ? sanitizeArgs(sample.normalizedArgs) : sample.normalizedArgs
+        };
+        const id = `sample_${stableSampleId(sanitized)}`;
+        const file = path.join(typeDir, `${id}.json`);
+        if (fs.existsSync(file))
+            return;
+        const fullSample = {
+            id,
+            timestamp: new Date().toISOString(),
+            ...sanitized
+        };
+        fs.writeFileSync(file, JSON.stringify(fullSample, null, 2), 'utf-8');
+    }
+    catch {
+        // Silently fail to avoid disrupting runtime
+    }
+}

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

@@ -0,0 +1,10 @@
+export type ExecCommandValidationResult = {
+    ok: boolean;
+    reason?: string;
+    message?: string;
+    normalizedArgs?: string;
+};
+export type ExecCommandValidationOptions = {
+    policyFile?: string;
+};
+export declare function validateExecCommandArgs(argsString: string, rawArgs: unknown, options?: ExecCommandValidationOptions): ExecCommandValidationResult;