@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

package/dist/core/src/config/config-parser.js

@@ -1,173 +0,0 @@
-/**
- * Configuration Parser
- *
- * Provides JSONC parsing and environment/protocol variable substitution
- */
-import { parse as parseJSONCInternal } from "jsonc-parser";
-/**
- * Parse JSONC (JSON with Comments) content
- * Supports single-line comments (//) and multi-line comments
- *
- * @param content - JSONC content string
- * @returns Parsed JSON object
- */
-export function parseJSONC(content) {
-    const errors = [];
-    const result = parseJSONCInternal(content, errors, {
-        allowTrailingComma: true,
-        disallowComments: false,
-    });
-    if (errors.length > 0) {
-        // 过滤掉"没有值"的警告（文件只有注释时会出现）
-        // 只有当 result 是 undefined 且只有一个 ValueExpected 错误时才忽略
-        const hasOnlyValueExpected = result === undefined &&
-            errors.length === 1 &&
-            errors[0].error === 4 /* ParseErrorCode.ValueExpected */;
-        if (!hasOnlyValueExpected) {
-            const error = errors[0];
-            const offset = error.offset;
-            const lines = content.substring(0, offset).split("\n");
-            const line = lines.length;
-            const col = lines[lines.length - 1].length + 1;
-            const errorMessages = {
-                [12 /* ParseErrorCode.UnexpectedEndOfString */]: "Unexpected end of string",
-                [16 /* ParseErrorCode.InvalidCharacter */]: "Invalid character",
-                [3 /* ParseErrorCode.PropertyNameExpected */]: "Property name expected",
-                [4 /* ParseErrorCode.ValueExpected */]: "Value expected",
-                [5 /* ParseErrorCode.ColonExpected */]: "Colon expected",
-                [6 /* ParseErrorCode.CommaExpected */]: "Comma expected",
-                [7 /* ParseErrorCode.CloseBraceExpected */]: "Close brace expected",
-                [8 /* ParseErrorCode.CloseBracketExpected */]: "Close bracket expected",
-                [9 /* ParseErrorCode.EndOfFileExpected */]: "Unexpected end of input",
-                [1 /* ParseErrorCode.InvalidSymbol */]: "Invalid symbol",
-            };
-            throw new Error(`JSONC parse error at line ${line}, col ${col}: ${errorMessages[error.error] || "Unknown error"}`);
-        }
-    }
-    // 处理空内容（只有注释的情况）
-    if (result === undefined || result === null) {
-        return {};
-    }
-    return result;
-}
-/**
- * Substitute environment variables in a value
- * Supports ${VAR} and ${VAR:-default} syntax
- *
- * @param value - Value to substitute (string, object, array, or primitive)
- * @returns Value with environment variables substituted
- */
-export function substituteEnvVars(value) {
-    if (typeof value === "string") {
-        return value.replace(/\$\{([^}]+)\}/g, (match, varExpr) => {
-            const [varName, defaultValue] = varExpr.split(":-");
-            const envValue = process.env[varName.trim()];
-            if (envValue !== undefined) {
-                return envValue;
-            }
-            if (defaultValue !== undefined) {
-                return defaultValue;
-            }
-            return "";
-        });
-    }
-    if (Array.isArray(value)) {
-        return value.map(item => substituteEnvVars(item));
-    }
-    if (value !== null && typeof value === "object") {
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = substituteEnvVars(val);
-        }
-        return result;
-    }
-    return value;
-}
-/**
- * Parse JSONC content and substitute environment variables
- *
- * @param content - JSONC content string
- * @returns Parsed JSON object with env vars substituted
- */
-export function parseJSONCWithEnv(content) {
-    const parsed = parseJSONC(content);
-    return substituteEnvVars(parsed);
-}
-/**
- * Protocol reference pattern - 支持带默认值的协议引用
- * 格式: ${protocol://path#key:-default} 或 ${protocol://path:-default}
- */
-const PROTOCOL_REF_PATTERN = /^\$\{([^:]+):\/\/[^}]+\}$/;
-/**
- * Protocol reference with default value pattern
- * 格式: ${protocol://path#key:-default}
- */
-const PROTOCOL_REF_WITH_DEFAULT_PATTERN = /^\$\{([^:]+):\/\/([^:#]+)(?:#([^:-]+))?(?::-(.*))?\}$/;
-/**
- * Check if a string is a protocol reference
- */
-function isProtocolRefString(value) {
-    return PROTOCOL_REF_PATTERN.test(value);
-}
-/**
- * Extract default value from protocol reference string
- */
-function extractDefaultValue(ref) {
-    const match = ref.match(PROTOCOL_REF_WITH_DEFAULT_PATTERN);
-    return match ? match[4] : undefined;
-}
-/**
- * Substitute protocol references in a value using the provided resolver
- *
- * Supports:
- * - ${file://path#key} - Read from file
- * - ${env://varName} - Read from environment variable
- * - All above with default values: ${protocol://...:-default}
- *
- * @param value - Value to substitute (string, object, array, or primitive)
- * @param resolver - ProtocolResolver instance
- * @returns Value with protocol references substituted
- */
-export function substituteProtocolRefs(value, resolver) {
-    if (typeof value === "string") {
-        // 如果整个字符串就是协议引用，尝试解析
-        if (isProtocolRefString(value)) {
-            const result = resolver.resolve(value);
-            if (result !== null) {
-                return result.value;
-            }
-            // 解析失败，检查是否有默认值
-            const defaultValue = extractDefaultValue(value);
-            if (defaultValue !== undefined) {
-                return defaultValue;
-            }
-        }
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map(item => substituteProtocolRefs(item, resolver));
-    }
-    if (value !== null && typeof value === "object") {
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = substituteProtocolRefs(val, resolver);
-        }
-        return result;
-    }
-    return value;
-}
-/**
- * Parse JSONC content and substitute protocol references
- *
- * @param content - JSONC content string
- * @param resolver - ProtocolResolver instance
- * @returns Parsed JSON object with protocol refs substituted
- */
-export function parseJSONCWithProtocols(content, resolver) {
-    const parsed = parseJSONC(content);
-    // 先解析协议引用（保护协议引用不被环境变量替换破坏）
-    const withProtocols = substituteProtocolRefs(parsed, resolver);
-    // 再解析环境变量（只处理非协议引用的字符串）
-    return substituteEnvVars(withProtocols);
-}
-//# sourceMappingURL=config-parser.js.map

package/dist/core/src/config/config-parser.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=config-parser.test.d.ts.map

package/dist/core/src/config/config-parser.test.js

@@ -1,252 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import * as path from "path";
-import { ProtocolResolver } from "./protocol-resolver.js";
-describe("parseJSONC", () => {
-    test("should parse valid JSON", () => {
-        // Dynamic import to ensure module is loaded
-        const { parseJSONC } = require("./config-parser");
-        const content = '{"name": "test", "value": 123}';
-        const result = parseJSONC(content);
-        expect(result).toEqual({ name: "test", value: 123 });
-    });
-    test("should handle single-line comments", () => {
-        const { parseJSONC } = require("./config-parser");
-        const content = `{
-      // This is a comment
-      "name": "test"
-    }`;
-        const result = parseJSONC(content);
-        expect(result).toEqual({ name: "test" });
-    });
-    test("should handle multi-line comments", () => {
-        const { parseJSONC } = require("./config-parser");
-        const content = `{
-      /* This is
-         a multi-line
-         comment */
-      "name": "test"
-    }`;
-        const result = parseJSONC(content);
-        expect(result).toEqual({ name: "test" });
-    });
-    test("should handle trailing comments", () => {
-        const { parseJSONC } = require("./config-parser");
-        const content = `{
-      "name": "test"  // trailing comment
-    }`;
-        const result = parseJSONC(content);
-        expect(result).toEqual({ name: "test" });
-    });
-    test("should handle mixed comments", () => {
-        const { parseJSONC } = require("./config-parser");
-        const content = `{
-      // Header comment
-      "name": "test",  // inline comment
-      /* Block comment */
-      "value": 123
-    }`;
-        const result = parseJSONC(content);
-        expect(result).toEqual({ name: "test", value: 123 });
-    });
-    test("should handle empty JSONC file", () => {
-        const { parseJSONC } = require("./config-parser");
-        const result = parseJSONC("// just a comment\n\n// another comment");
-        expect(result).toEqual({});
-    });
-});
-describe("substituteEnvVars", () => {
-    test("should substitute simple env var", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        process.env.TEST_VAR = "hello";
-        const result = substituteEnvVars("${TEST_VAR}");
-        expect(result).toBe("hello");
-        delete process.env.TEST_VAR;
-    });
-    test("should handle missing env var with empty string", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        delete process.env.NONEXISTENT_VAR;
-        const result = substituteEnvVars("${NONEXISTENT_VAR}");
-        expect(result).toBe("");
-    });
-    test("should handle default value syntax", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        delete process.env.NONEXISTENT_VAR;
-        const result = substituteEnvVars("${NONEXISTENT_VAR:-fallback}");
-        expect(result).toBe("fallback");
-    });
-    test("should prefer env var over default", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        process.env.EXISTING_VAR = "actual";
-        const result = substituteEnvVars("${EXISTING_VAR:-default}");
-        expect(result).toBe("actual");
-        delete process.env.EXISTING_VAR;
-    });
-    test("should substitute in object values", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        process.env.API_KEY = "secret123";
-        const result = substituteEnvVars({ apiKey: "${API_KEY}" });
-        expect(result).toEqual({ apiKey: "secret123" });
-        delete process.env.API_KEY;
-    });
-    test("should handle nested objects", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        process.env.HOST = "localhost";
-        process.env.PORT = "3000";
-        const result = substituteEnvVars({
-            server: { host: "${HOST}", port: "${PORT}" }
-        });
-        expect(result).toEqual({ server: { host: "localhost", port: "3000" } });
-        delete process.env.HOST;
-        delete process.env.PORT;
-    });
-    test("should preserve non-string values", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        process.env.NUM = "42";
-        const result = substituteEnvVars({ count: "${NUM}", enabled: true, rate: 0.5 });
-        expect(result).toEqual({ count: "42", enabled: true, rate: 0.5 });
-        delete process.env.NUM;
-    });
-    test("should handle arrays", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        process.env.ITEM1 = "a";
-        process.env.ITEM2 = "b";
-        const result = substituteEnvVars(["${ITEM1}", "${ITEM2}"]);
-        expect(result).toEqual(["a", "b"]);
-        delete process.env.ITEM1;
-        delete process.env.ITEM2;
-    });
-    test("should handle mixed arrays with strings and values", () => {
-        const { substituteEnvVars } = require("./config-parser");
-        process.env.VALUE = "test";
-        const result = substituteEnvVars(["${VALUE}", 123, true, null]);
-        expect(result).toEqual(["test", 123, true, null]);
-        delete process.env.VALUE;
-    });
-});
-describe("parseJSONCWithEnv", () => {
-    test("should parse JSONC and substitute env vars", () => {
-        const { parseJSONCWithEnv } = require("./config-parser");
-        process.env.API_KEY = "my-secret";
-        const content = '{\n      // API Configuration\n      "apiKey": "${API_KEY}",\n      "model": "gpt-4o"\n    }';
-        const result = parseJSONCWithEnv(content);
-        expect(result).toEqual({ apiKey: "my-secret", model: "gpt-4o" });
-        delete process.env.API_KEY;
-    });
-});
-describe("substituteProtocolRefs", () => {
-    const testDir = path.join(__dirname, ".test-protocol-subst");
-    let resolver;
-    beforeEach(async () => {
-        // 创建测试目录
-        await fs.promises.mkdir(testDir, { recursive: true });
-        resolver = new ProtocolResolver({ xdgDataHome: testDir });
-    });
-    afterEach(async () => {
-        // 清理测试目录
-        try {
-            await fs.promises.rm(testDir, { recursive: true, force: true });
-        }
-        catch {
-            // ignore
-        }
-    });
-    test("should substitute file:// protocol reference", async () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        // 创建测试文件
-        const configPath = path.join(testDir, "api.json");
-        await fs.promises.writeFile(configPath, JSON.stringify({ key: "file-key-123" }), "utf-8");
-        const result = substituteProtocolRefs("${file://api.json#key}", resolver);
-        expect(result).toBe("file-key-123");
-    });
-    test("should substitute file:// protocol reference from external file", async () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        const refPath = path.join(testDir, "ref.json");
-        await fs.promises.writeFile(refPath, JSON.stringify({ token: "file-token-456" }), "utf-8");
-        const fileResolver = new ProtocolResolver({
-            xdgDataHome: testDir,
-        });
-        const result = substituteProtocolRefs("${file://ref.json#token}", fileResolver);
-        expect(result).toBe("file-token-456");
-    });
-    test("should substitute env:// protocol reference", () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        process.env.PROTOCOL_TEST_VAR = "env-value-789";
-        const result = substituteProtocolRefs("${env://PROTOCOL_TEST_VAR}", resolver);
-        expect(result).toBe("env-value-789");
-        delete process.env.PROTOCOL_TEST_VAR;
-    });
-    test("should preserve original value when protocol reference is invalid", () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        const result = substituteProtocolRefs("plain text", resolver);
-        expect(result).toBe("plain text");
-    });
-    test("should preserve original value when file does not exist", () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        const result = substituteProtocolRefs("${file://nonexistent.json#key}", resolver);
-        expect(result).toBe("${file://nonexistent.json#key}");
-    });
-    test("should substitute in object values", async () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        const configPath = path.join(testDir, "server.json");
-        await fs.promises.writeFile(configPath, JSON.stringify({ host: "localhost", port: 8080 }), "utf-8");
-        const result = substituteProtocolRefs({ api: "${file://server.json#host}", port: "${file://server.json#port}" }, resolver);
-        expect(result).toEqual({ api: "localhost", port: 8080 });
-    });
-    test("should handle nested objects", async () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        const configPath = path.join(testDir, "nested.json");
-        await fs.promises.writeFile(configPath, JSON.stringify({
-            db: { host: "db.example.com", credentials: { user: "admin" } }
-        }), "utf-8");
-        const result = substituteProtocolRefs({ connection: "${file://nested.json#db.host}", user: "${file://nested.json#db.credentials.user}" }, resolver);
-        expect(result).toEqual({ connection: "db.example.com", user: "admin" });
-    });
-    test("should preserve non-string values", () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        const result = substituteProtocolRefs({ count: 123, enabled: true, data: null }, resolver);
-        expect(result).toEqual({ count: 123, enabled: true, data: null });
-    });
-    test("should handle arrays with protocol references", async () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        const configPath = path.join(testDir, "items.json");
-        await fs.promises.writeFile(configPath, JSON.stringify({ item1: "a", item2: "b" }), "utf-8");
-        const result = substituteProtocolRefs(["${file://items.json#item1}", "${file://items.json#item2}"], resolver);
-        expect(result).toEqual(["a", "b"]);
-    });
-    test("should handle mixed arrays with protocol references and regular values", async () => {
-        const { substituteProtocolRefs } = require("./config-parser");
-        const configPath = path.join(testDir, "mixed.json");
-        await fs.promises.writeFile(configPath, JSON.stringify({ value: "from-file" }), "utf-8");
-        const result = substituteProtocolRefs(["${file://mixed.json#value}", 123, true, "plain"], resolver);
-        expect(result).toEqual(["from-file", 123, true, "plain"]);
-    });
-});
-describe("parseJSONCWithProtocols", () => {
-    const testDir = path.join(__dirname, ".test-protocol-parse");
-    let resolver;
-    beforeEach(async () => {
-        await fs.promises.mkdir(testDir, { recursive: true });
-        resolver = new ProtocolResolver({ xdgDataHome: testDir });
-    });
-    afterEach(async () => {
-        try {
-            await fs.promises.rm(testDir, { recursive: true, force: true });
-        }
-        catch {
-            // ignore
-        }
-    });
-    test("should parse JSONC and substitute protocol refs", async () => {
-        // 注意：JSONC 的单行注释解析器会错误处理字符串内部的 "//" 语法
-        // 所以这里使用 substituteProtocolRefs 直接测试，绕过 JSONC 解析
-        const { substituteProtocolRefs } = require("./config-parser");
-        const configPath = path.join(testDir, "api.json");
-        await fs.promises.writeFile(configPath, JSON.stringify({ key: "secret-key" }), "utf-8");
-        // 先创建已解析的 JSON 对象（模拟 parseJSONC 的结果）
-        const parsed = { apiKey: "${file://api.json#key}", model: "gpt-4o" };
-        const result = substituteProtocolRefs(parsed, resolver);
-        expect(result).toEqual({ apiKey: "secret-key", model: "gpt-4o" });
-    });
-});
-//# sourceMappingURL=config-parser.test.js.map

package/dist/core/src/config/decentralized-config.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=decentralized-config.test.d.ts.map