@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/config/env-source.test.js

@@ -0,0 +1,196 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { EnvSource } from "./env-source.js";
+describe("EnvSource", () => {
+    // 保存原始环境变量
+    const originalEnv = { ...process.env };
+    beforeEach(() => {
+        // 重置环境变量
+        process.env = { ...originalEnv };
+        // 删除测试相关变量
+        delete process.env.TEST_VAR;
+        delete process.env.NESTED_VAR;
+        delete process.env["USER.PROFILE.NAME"];
+        delete process.env.PREFIX_TEST_ONE;
+        delete process.env.PREFIX_TEST_TWO;
+    });
+    afterEach(() => {
+        // 恢复原始环境变量
+        process.env = originalEnv;
+    });
+    test("read returns undefined for non-existent key", () => {
+        const source = new EnvSource();
+        const value = source.read("NON_EXISTENT_VAR");
+        expect(value).toBeUndefined();
+    });
+    test("read returns value from environment variable", () => {
+        process.env.TEST_VAR = "hello world";
+        const source = new EnvSource();
+        expect(source.read("TEST_VAR")).toBe("hello world");
+    });
+    test("read converts key to uppercase", () => {
+        process.env.TEST_VAR = "value";
+        const source = new EnvSource();
+        expect(source.read("test_var")).toBe("value");
+        expect(source.read("TEST_VAR")).toBe("value");
+    });
+    test("read supports prefix matching", () => {
+        process.env.MY_APP_DEBUG = "true";
+        process.env.MY_APP_PORT = "8080";
+        process.env.OTHER_VAR = "ignored";
+        const source = new EnvSource({ prefix: "MY_APP_" });
+        expect(source.read("DEBUG")).toBe("true");
+        expect(source.read("PORT")).toBe("8080");
+        expect(source.read("OTHER_VAR")).toBeUndefined();
+    });
+    test("read returns original key if prefix doesn't match", () => {
+        process.env.MY_APP_DEBUG = "true";
+        const source = new EnvSource({ prefix: "OTHER_" });
+        expect(source.read("DEBUG")).toBeUndefined();
+        expect(source.read("MY_APP_DEBUG")).toBeUndefined();
+    });
+    test("read returns string value by default", () => {
+        process.env.TEST_STRING = "hello";
+        process.env.TEST_NUMBER = "42";
+        const source = new EnvSource();
+        expect(source.read("TEST_STRING")).toBe("hello");
+        expect(source.read("TEST_NUMBER")).toBe("42");
+    });
+    test("read applies transform function", () => {
+        process.env.TEST_BOOL = "true";
+        process.env.TEST_NUM = "42";
+        const source = new EnvSource({
+            transform: (value, key) => {
+                if (key.endsWith("_BOOL"))
+                    return value === "true";
+                if (key.endsWith("_NUM"))
+                    return parseInt(value, 10);
+                return value;
+            },
+        });
+        expect(source.read("TEST_BOOL")).toBe(true);
+        expect(source.read("TEST_NUM")).toBe(42);
+    });
+    test("write sets environment variable", () => {
+        const source = new EnvSource();
+        const result = source.write("TEST_VAR", "new value");
+        expect(result).toBe(true);
+        expect(process.env.TEST_VAR).toBe("new value");
+    });
+    test("write applies prefix", () => {
+        const source = new EnvSource({ prefix: "APP_" });
+        source.write("DEBUG", "true");
+        expect(process.env.APP_DEBUG).toBe("true");
+    });
+    test("write applies transform function", () => {
+        const source = new EnvSource({
+            transform: (value) => String(value),
+        });
+        source.write("TEST_NUM", 42);
+        expect(process.env.TEST_NUM).toBe("42");
+    });
+    test("write converts key to uppercase", () => {
+        const source = new EnvSource();
+        source.write("test_var", "value");
+        expect(process.env.TEST_VAR).toBe("value");
+    });
+    test("delete removes environment variable", () => {
+        process.env.TEST_VAR = "value";
+        const source = new EnvSource();
+        const result = source.delete("TEST_VAR");
+        expect(result).toBe(true);
+        expect(process.env.TEST_VAR).toBeUndefined();
+    });
+    test("delete returns false for non-existent key", () => {
+        const source = new EnvSource();
+        const result = source.delete("NON_EXISTENT");
+        expect(result).toBe(false);
+    });
+    test("delete applies prefix", () => {
+        process.env.APP_TEST = "value";
+        const source = new EnvSource({ prefix: "APP_" });
+        const result = source.delete("TEST");
+        expect(result).toBe(true);
+        expect(process.env.APP_TEST).toBeUndefined();
+    });
+    test("list returns all environment variables", () => {
+        process.env.TEST_ONE = "1";
+        process.env.TEST_TWO = "2";
+        process.env.OTHER = "3";
+        const source = new EnvSource();
+        const entries = source.list();
+        const testEntries = entries.filter((e) => e.key.startsWith("TEST_"));
+        expect(testEntries).toContainEqual({ key: "TEST_ONE", value: "1" });
+        expect(testEntries).toContainEqual({ key: "TEST_TWO", value: "2" });
+    });
+    test("list applies prefix filter", () => {
+        process.env.MY_APP_DEBUG = "true";
+        process.env.MY_APP_PORT = "8080";
+        process.env.OTHER_VAR = "ignored";
+        const source = new EnvSource({ prefix: "MY_APP_" });
+        const entries = source.list();
+        expect(entries).toContainEqual({ key: "DEBUG", value: "true" });
+        expect(entries).toContainEqual({ key: "PORT", value: "8080" });
+        expect(entries).not.toContainEqual(expect.objectContaining({ key: "OTHER_VAR" }));
+    });
+    test("list removes prefix from keys", () => {
+        process.env.APP_DEBUG = "true";
+        const source = new EnvSource({ prefix: "APP_" });
+        const entries = source.list();
+        expect(entries).toContainEqual({ key: "DEBUG", value: "true" });
+        expect(entries).not.toContainEqual(expect.objectContaining({ key: "APP_DEBUG" }));
+    });
+    test("watch monitors environment changes", async () => {
+        const source = new EnvSource({ pollInterval: 50 });
+        const events = [];
+        const unwatch = source.watch((event) => {
+            events.push(event);
+        });
+        // 等待 watcher 初始化
+        await new Promise((r) => setTimeout(r, 100));
+        // 修改环境变量
+        process.env.TEST_VAR = "changed";
+        // 等待事件触发（需要轮询间隔）
+        await new Promise((r) => setTimeout(r, 150));
+        unwatch();
+        expect(events.length).toBeGreaterThan(0);
+    });
+    test("watch returns unsubscribe function", async () => {
+        const source = new EnvSource({ pollInterval: 50 });
+        let called = false;
+        const wrappedCallback = (event) => { called = true; };
+        const unwatch = source.watch(wrappedCallback);
+        // 等待 watcher 初始化
+        await new Promise((r) => setTimeout(r, 100));
+        unwatch();
+        process.env.TEST_VAR = "changed";
+        // 等待事件触发（需要轮询间隔）
+        await new Promise((r) => setTimeout(r, 150));
+        expect(called).toBe(false);
+    });
+    test("has correct name and priority", () => {
+        const source = new EnvSource();
+        expect(source.name).toBe("env");
+        expect(source.priority).toBe(20);
+    });
+    test("default priority is higher than file source", () => {
+        const envSource = new EnvSource();
+        expect(envSource.priority).toBe(20);
+    });
+    test("transform receives key and value", () => {
+        process.env.TEST_VAR = "original";
+        let receivedKey = "";
+        let receivedValue = "";
+        const source = new EnvSource({
+            transform: (value, key) => {
+                receivedKey = key;
+                receivedValue = value;
+                return value.toUpperCase();
+            },
+        });
+        const result = source.read("TEST_VAR");
+        expect(result).toBe("ORIGINAL");
+        expect(receivedKey).toBe("TEST_VAR");
+        expect(receivedValue).toBe("original");
+    });
+});
+//# sourceMappingURL=env-source.test.js.map

package/dist/core/src/config/file-source.d.ts

@@ -0,0 +1,87 @@
+import { ConfigSource, ConfigSourceType, ConfigChangeEvent } from "./config-component";
+import { ProtocolResolver } from "./protocol-resolver";
+/**
+ * FileSource 配置
+ */
+export interface FileSourceOptions {
+    /** 文件路径 */
+    filePath: string;
+    /** 写入防抖延迟（ms），默认 100ms */
+    debounceMs?: number;
+    /** 协议解析器（可选），用于解析 file://, env:// 协议 */
+    resolver?: ProtocolResolver;
+    /** 是否可选，文件不存在时不报错（默认 false） */
+    optional?: boolean;
+    /** 是否启用文件监听（默认 true） */
+    watch?: boolean;
+}
+/**
+ * 文件配置源
+ *
+ * 从 JSON 文件读取/写入配置，支持：
+ * - 点号访问嵌套值（user.profile.name）
+ * - 文件监听
+ * - 异步批量写入
+ * - 协议引用解析 (file://, env://)
+ */
+export declare class FileSource implements ConfigSource {
+    readonly name: ConfigSourceType;
+    readonly priority = 10;
+    private filePath;
+    private data;
+    private watchers;
+    private watcherHandle?;
+    private debounceMs;
+    private pendingWrite?;
+    private lastFileContent;
+    private resolver?;
+    private optional;
+    private watchEnabled;
+    constructor(options: FileSourceOptions | string, resolver?: ProtocolResolver);
+    /**
+     * 同步初始化：加载文件内容
+     */
+    private initSync;
+    /**
+     * 异步初始化
+     */
+    private ensureInit;
+    /**
+     * 获取嵌套值
+     */
+    private getNestedValue;
+    /**
+     * 设置嵌套值
+     */
+    private setNestedValue;
+    /**
+     * 删除嵌套值
+     */
+    private deleteNestedValue;
+    /**
+     * 扁平化嵌套对象为点号路径
+     */
+    private flattenObject;
+    read(key: string): unknown | undefined;
+    readAsync(key: string): Promise<unknown | undefined>;
+    write(key: string, value: unknown): boolean;
+    private scheduleWrite;
+    private persistToFile;
+    delete(key: string): boolean;
+    list(): Array<{
+        key: string;
+        value: unknown;
+    }>;
+    listAsync(): Promise<Array<{
+        key: string;
+        value: unknown;
+    }>>;
+    watch(callback: (event: ConfigChangeEvent) => void): () => void;
+    private ensureWatch;
+    private stopWatch;
+    private reloadFromFile;
+    private notifyWatchers;
+    refresh(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=file-source.d.ts.map

package/dist/core/src/config/file-source.js

@@ -0,0 +1,349 @@
+import * as fsSync from "fs";
+import * as fsPromises from "fs/promises";
+import path from "path";
+import { parseJSONCWithEnv, parseJSONCWithProtocols } from "./config-parser.js";
+/**
+ * 文件配置源
+ *
+ * 从 JSON 文件读取/写入配置，支持：
+ * - 点号访问嵌套值（user.profile.name）
+ * - 文件监听
+ * - 异步批量写入
+ * - 协议引用解析 (file://, env://)
+ */
+export class FileSource {
+    name = "file";
+    priority = 10;
+    filePath;
+    data = {};
+    watchers = new Set();
+    watcherHandle;
+    debounceMs;
+    pendingWrite;
+    lastFileContent = "";
+    resolver;
+    optional = false;
+    watchEnabled = true;
+    constructor(options, resolver) {
+        if (typeof options === "string") {
+            this.filePath = options;
+            this.debounceMs = 100;
+            this.resolver = resolver;
+            this.optional = true; // 字符串构造默认为可选，保持向后兼容
+        }
+        else {
+            this.filePath = options.filePath;
+            this.debounceMs = options.debounceMs ?? 100;
+            this.resolver = options.resolver ?? resolver;
+            this.optional = options.optional ?? true; // 对象构造默认为可选
+            this.watchEnabled = options.watch ?? true;
+        }
+        // 同步初始化
+        this.initSync();
+    }
+    /**
+     * 同步初始化：加载文件内容
+     */
+    initSync() {
+        try {
+            if (fsSync.existsSync(this.filePath)) {
+                const content = fsSync.readFileSync(this.filePath, "utf-8");
+                // 如果配置了 resolver，使用 parseJSONCWithProtocols 解析协议引用
+                if (this.resolver) {
+                    this.data = parseJSONCWithProtocols(content, this.resolver);
+                }
+                else {
+                    this.data = parseJSONCWithEnv(content);
+                }
+                this.lastFileContent = content;
+            }
+            else {
+                if (this.optional) {
+                    // 可选文件不存在时，静默初始化为空对象
+                    this.data = {};
+                    this.lastFileContent = "{}";
+                }
+                else {
+                    // 必需文件不存在时，抛出错误
+                    throw new Error(`Config file not found: ${this.filePath}`);
+                }
+            }
+        }
+        catch (error) {
+            if (this.optional) {
+                // 可选文件出错时，静默初始化为空对象
+                this.data = {};
+                this.lastFileContent = "{}";
+            }
+            else {
+                // 必需文件出错时，重新抛出错误
+                throw error;
+            }
+        }
+    }
+    /**
+     * 异步初始化
+     */
+    async ensureInit() {
+        if (this.lastFileContent === "" && !fsSync.existsSync(this.filePath)) {
+            // 尚未初始化，执行同步初始化
+            this.initSync();
+        }
+    }
+    /**
+     * 获取嵌套值
+     */
+    getNestedValue(obj, key) {
+        const keys = key.split(".");
+        let current = obj;
+        for (const k of keys) {
+            if (current === null || current === undefined || typeof current !== "object") {
+                return undefined;
+            }
+            current = current[k];
+        }
+        return current;
+    }
+    /**
+     * 设置嵌套值
+     */
+    setNestedValue(obj, key, value) {
+        const keys = key.split(".");
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const k = keys[i];
+            if (!(k in current) || typeof current[k] !== "object" || current[k] === null) {
+                current[k] = {};
+            }
+            current = current[k];
+        }
+        current[keys[keys.length - 1]] = value;
+    }
+    /**
+     * 删除嵌套值
+     */
+    deleteNestedValue(obj, key) {
+        const keys = key.split(".");
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const k = keys[i];
+            if (!(k in current) || typeof current[k] !== "object" || current[k] === null) {
+                return false;
+            }
+            current = current[k];
+        }
+        const lastKey = keys[keys.length - 1];
+        if (lastKey in current) {
+            delete current[lastKey];
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 扁平化嵌套对象为点号路径
+     */
+    flattenObject(obj, prefix = "") {
+        if (obj === null || obj === undefined) {
+            return [];
+        }
+        if (typeof obj !== "object") {
+            return prefix ? [{ key: prefix, value: obj }] : [];
+        }
+        if (Array.isArray(obj)) {
+            return prefix ? [{ key: prefix, value: obj }] : [];
+        }
+        const result = [];
+        const entries = Object.entries(obj);
+        for (const [k, v] of entries) {
+            const newKey = prefix ? `${prefix}.${k}` : k;
+            if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+                result.push(...this.flattenObject(v, newKey));
+            }
+            else {
+                result.push({ key: newKey, value: v });
+            }
+        }
+        return result;
+    }
+    read(key) {
+        return this.getNestedValue(this.data, key);
+    }
+    async readAsync(key) {
+        await this.ensureInit();
+        return this.getNestedValue(this.data, key);
+    }
+    write(key, value) {
+        const oldValue = this.getNestedValue(this.data, key);
+        this.setNestedValue(this.data, key, value);
+        const event = {
+            type: oldValue === undefined ? "add" : "change",
+            key,
+            oldValue,
+            newValue: value,
+            source: this.name,
+            timestamp: Date.now(),
+        };
+        this.notifyWatchers(event);
+        this.scheduleWrite();
+        return true;
+    }
+    scheduleWrite() {
+        if (this.pendingWrite) {
+            clearTimeout(this.pendingWrite);
+        }
+        this.pendingWrite = setTimeout(() => {
+            this.persistToFile();
+        }, this.debounceMs);
+    }
+    persistToFile() {
+        try {
+            const dir = path.dirname(this.filePath);
+            if (!fsSync.existsSync(dir)) {
+                fsSync.mkdirSync(dir, { recursive: true });
+            }
+            const content = JSON.stringify(this.data, null, 2);
+            fsSync.writeFileSync(this.filePath, content, "utf-8");
+            this.lastFileContent = content;
+        }
+        catch (error) {
+            console.error(`Failed to write config to ${this.filePath}:`, error);
+        }
+    }
+    delete(key) {
+        const oldValue = this.getNestedValue(this.data, key);
+        if (oldValue === undefined) {
+            return false;
+        }
+        this.deleteNestedValue(this.data, key);
+        const event = {
+            type: "delete",
+            key,
+            oldValue,
+            newValue: undefined,
+            source: this.name,
+            timestamp: Date.now(),
+        };
+        this.notifyWatchers(event);
+        this.scheduleWrite();
+        return true;
+    }
+    list() {
+        return this.flattenObject(this.data);
+    }
+    async listAsync() {
+        await this.ensureInit();
+        return this.flattenObject(this.data);
+    }
+    watch(callback) {
+        this.watchers.add(callback);
+        // 如果 watch 被禁用，直接返回
+        if (!this.watchEnabled) {
+            return () => {
+                this.watchers.delete(callback);
+            };
+        }
+        this.ensureWatch();
+        return () => {
+            this.watchers.delete(callback);
+            if (this.watchers.size === 0) {
+                this.stopWatch();
+            }
+        };
+    }
+    async ensureWatch() {
+        if (this.watcherHandle !== undefined) {
+            return;
+        }
+        await this.ensureInit();
+        // 可选文件不存在时不尝试监听
+        if (!fsSync.existsSync(this.filePath)) {
+            return;
+        }
+        try {
+            this.watcherHandle = fsSync.watch(this.filePath, async (eventType) => {
+                if (eventType === "change") {
+                    await new Promise((r) => setTimeout(r, 50));
+                    await this.reloadFromFile();
+                }
+            });
+        }
+        catch (error) {
+            console.error(`Failed to watch file ${this.filePath}:`, error);
+        }
+    }
+    stopWatch() {
+        if (this.watcherHandle) {
+            this.watcherHandle.close();
+            this.watcherHandle = undefined;
+        }
+    }
+    async reloadFromFile() {
+        try {
+            const content = await fsPromises.readFile(this.filePath, "utf-8");
+            if (content === this.lastFileContent) {
+                return;
+            }
+            const newData = parseJSONCWithEnv(content);
+            const oldData = this.data;
+            this.data = newData;
+            this.lastFileContent = content;
+            const oldFlat = this.flattenObject(oldData);
+            const newFlat = this.flattenObject(newData);
+            const oldKeys = new Set(oldFlat.map((e) => e.key));
+            const newKeys = new Set(newFlat.map((e) => e.key));
+            for (const key of oldKeys) {
+                if (!newKeys.has(key)) {
+                    this.notifyWatchers({
+                        type: "delete",
+                        key,
+                        oldValue: oldFlat.find((e) => e.key === key)?.value,
+                        newValue: undefined,
+                        source: this.name,
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            for (const newEntry of newFlat) {
+                const oldEntry = oldFlat.find((e) => e.key === newEntry.key);
+                if (!oldEntry) {
+                    this.notifyWatchers({
+                        type: "add",
+                        key: newEntry.key,
+                        oldValue: undefined,
+                        newValue: newEntry.value,
+                        source: this.name,
+                        timestamp: Date.now(),
+                    });
+                }
+                else if (oldEntry.value !== newEntry.value) {
+                    this.notifyWatchers({
+                        type: "change",
+                        key: newEntry.key,
+                        oldValue: oldEntry.value,
+                        newValue: newEntry.value,
+                        source: this.name,
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Failed to reload config from ${this.filePath}:`, error);
+        }
+    }
+    notifyWatchers(event) {
+        this.watchers.forEach((cb) => cb(event));
+    }
+    async refresh() {
+        await this.reloadFromFile();
+    }
+    async close() {
+        this.stopWatch();
+        if (this.pendingWrite) {
+            clearTimeout(this.pendingWrite);
+            this.pendingWrite = undefined;
+        }
+        this.persistToFile();
+    }
+}
+//# sourceMappingURL=file-source.js.map

package/dist/core/src/config/file-source.test.d.ts

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