@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

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

@@ -0,0 +1,173 @@
+/**
+ * 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

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

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

@@ -0,0 +1,252 @@
+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

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