comisai 1.0.10 → 1.0.12

package/node_modules/@comis/core/dist/config/layered.test.js

@@ -1,211 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { describe, it, expect, afterEach } from "vitest";
-import { deepMerge, mergeLayered, loadLayered } from "./layered.js";
-describe("config/layered", () => {
-    const tmpDirs = [];
-    function makeTmpDir() {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "comis-layered-"));
-        tmpDirs.push(dir);
-        return dir;
-    }
-    function writeYaml(dir, name, content) {
-        const filePath = path.join(dir, name);
-        fs.writeFileSync(filePath, content, "utf-8");
-        return filePath;
-    }
-    afterEach(() => {
-        for (const dir of tmpDirs) {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-        tmpDirs.length = 0;
-    });
-    describe("deepMerge", () => {
-        it("merges flat objects", () => {
-            const result = deepMerge({ a: 1, b: 2 }, { b: 3, c: 4 });
-            expect(result).toEqual({ a: 1, b: 3, c: 4 });
-        });
-        it("deep merges nested objects", () => {
-            const result = deepMerge({ agent: { name: "Bot", maxSteps: 10 } }, { agent: { maxSteps: 20 } });
-            expect(result).toEqual({ agent: { name: "Bot", maxSteps: 20 } });
-        });
-        it("replaces arrays entirely (no concatenation)", () => {
-            const result = deepMerge({ security: { permission: { allowedFsPaths: ["/a", "/b"] } } }, { security: { permission: { allowedFsPaths: ["/c"] } } });
-            expect(result.security.permission
-                .allowedFsPaths).toEqual(["/c"]);
-        });
-        it("ignores undefined values in override", () => {
-            const result = deepMerge({ a: 1, b: 2 }, { a: undefined, b: 3 });
-            expect(result).toEqual({ a: 1, b: 3 });
-        });
-        it("overrides primitives", () => {
-            const result = deepMerge({ logLevel: "info" }, { logLevel: "debug" });
-            expect(result).toEqual({ logLevel: "debug" });
-        });
-        describe("prototype pollution defense", () => {
-            it("skips __proto__ keys", () => {
-                const base = { a: 1 };
-                const override = JSON.parse('{"__proto__": {"polluted": true}, "b": 2}');
-                const result = deepMerge(base, override);
-                expect(result).toEqual({ a: 1, b: 2 });
-                expect(result.__proto__).toBe(Object.prototype);
-                expect(Object.prototype.polluted).toBeUndefined();
-            });
-            it("skips constructor keys", () => {
-                const base = { a: 1 };
-                const override = JSON.parse('{"constructor": {"polluted": true}, "b": 2}');
-                const result = deepMerge(base, override);
-                expect(result).toEqual({ a: 1, b: 2 });
-                expect(result.constructor).toBe(Object);
-            });
-            it("skips prototype keys", () => {
-                const base = { a: 1 };
-                const override = JSON.parse('{"prototype": {"polluted": true}, "b": 2}');
-                const result = deepMerge(base, override);
-                expect(result).toEqual({ a: 1, b: 2 });
-            });
-            it("skips proto keys in nested objects (recursive defense)", () => {
-                const base = { nested: { a: 1 } };
-                const override = JSON.parse('{"nested": {"__proto__": {"polluted": true}, "b": 2}}');
-                const result = deepMerge(base, override);
-                expect(result).toEqual({ nested: { a: 1, b: 2 } });
-                expect(Object.prototype.polluted).toBeUndefined();
-            });
-            it("filters all three proto keys simultaneously", () => {
-                const base = {};
-                const override = JSON.parse('{"__proto__": {}, "constructor": {}, "prototype": {}, "safe": 1}');
-                const result = deepMerge(base, override);
-                expect(Object.keys(result)).toEqual(["safe"]);
-                expect(result).toEqual({ safe: 1 });
-            });
-        });
-    });
-    describe("mergeLayered", () => {
-        it("returns defaults for empty layers", () => {
-            const result = mergeLayered([]);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("default");
-                expect(result.value.logLevel).toBe("info");
-            }
-        });
-        it("validates and returns single layer", () => {
-            const result = mergeLayered([{ tenantId: "single" }]);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("single");
-            }
-        });
-        it("later layers override earlier layers", () => {
-            const result = mergeLayered([
-                { tenantId: "first", logLevel: "info" },
-                { tenantId: "second" },
-            ]);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("second");
-                expect(result.value.logLevel).toBe("info");
-            }
-        });
-        it("deep merges nested sections across layers", () => {
-            const result = mergeLayered([
-                { agents: { default: { name: "Base", maxSteps: 10 } } },
-                { agents: { default: { maxSteps: 50 } } },
-            ]);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.agents.default.name).toBe("Base");
-                expect(result.value.agents.default.maxSteps).toBe(50);
-            }
-        });
-        it("replaces arrays from later layers", () => {
-            const result = mergeLayered([
-                { channels: { telegram: { allowFrom: ["user1", "user2"] } } },
-                { channels: { telegram: { allowFrom: ["admin"] } } },
-            ]);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.channels.telegram.allowFrom).toEqual(["admin"]);
-            }
-        });
-        it("returns validation error for invalid merged config", () => {
-            const result = mergeLayered([{ logLevel: "invalid" }]);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("VALIDATION_ERROR");
-            }
-        });
-        it("migrates legacy streaming keys before validation", () => {
-            const result = mergeLayered([{
-                    streaming: {
-                        perChannel: {
-                            test: {
-                                pacingMinMs: 100,
-                                pacingMaxMs: 200,
-                                coalesceMaxChars: 400,
-                            },
-                        },
-                    },
-                }]);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                const testChannel = result.value.streaming.perChannel.test;
-                expect(testChannel).toBeDefined();
-                // New nested structure should be present
-                expect(testChannel.deliveryTiming.minMs).toBe(100);
-                expect(testChannel.deliveryTiming.maxMs).toBe(200);
-                expect(testChannel.coalescer.maxChars).toBe(400);
-                // Old flat keys should NOT be present
-                expect(testChannel.pacingMinMs).toBeUndefined();
-                expect(testChannel.pacingMaxMs).toBeUndefined();
-                expect(testChannel.coalesceMaxChars).toBeUndefined();
-            }
-        });
-    });
-    describe("loadLayered", () => {
-        it("loads and merges multiple config files", () => {
-            const dir = makeTmpDir();
-            const base = writeYaml(dir, "base.yaml", `
-tenantId: base
-logLevel: info
-agents:
-  default:
-    name: BaseBot
-    maxSteps: 10
-`);
-            const override = writeYaml(dir, "override.yaml", `
-tenantId: production
-agents:
-  default:
-    maxSteps: 50
-`);
-            const result = loadLayered([base, override]);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("production");
-                expect(result.value.agents.default.name).toBe("BaseBot");
-                expect(result.value.agents.default.maxSteps).toBe(50);
-                expect(result.value.logLevel).toBe("info");
-            }
-        });
-        it("returns error if any file is missing", () => {
-            const dir = makeTmpDir();
-            const existing = writeYaml(dir, "exists.yaml", "tenantId: ok\n");
-            const result = loadLayered([existing, "/does/not/exist.yaml"]);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("FILE_NOT_FOUND");
-            }
-        });
-        it("loads single file successfully", () => {
-            const dir = makeTmpDir();
-            const file = writeYaml(dir, "single.yaml", "tenantId: solo\n");
-            const result = loadLayered([file]);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("solo");
-            }
-        });
-    });
-});

package/node_modules/@comis/core/dist/config/loader.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/core/dist/config/loader.test.js

@@ -1,300 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { describe, it, expect, afterEach } from "vitest";
-import { loadConfigFile, validateConfig } from "./loader.js";
-describe("config/loader", () => {
-    const tmpDirs = [];
-    function makeTmpDir() {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "comis-config-"));
-        tmpDirs.push(dir);
-        return dir;
-    }
-    function writeFile(dir, name, content) {
-        const filePath = path.join(dir, name);
-        fs.writeFileSync(filePath, content, "utf-8");
-        return filePath;
-    }
-    afterEach(() => {
-        for (const dir of tmpDirs) {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-        tmpDirs.length = 0;
-    });
-    describe("loadConfigFile", () => {
-        it("loads valid YAML config", () => {
-            const dir = makeTmpDir();
-            const filePath = writeFile(dir, "config.yaml", `
-tenantId: test-tenant
-logLevel: debug
-agents:
-  default:
-    name: TestBot
-    maxSteps: 10
-`);
-            const result = loadConfigFile(filePath);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("test-tenant");
-                expect(result.value.logLevel).toBe("debug");
-                const agents = result.value.agents;
-                expect(agents.default.name).toBe("TestBot");
-            }
-        });
-        it("loads valid JSON config", () => {
-            const dir = makeTmpDir();
-            const filePath = writeFile(dir, "config.json", JSON.stringify({
-                tenantId: "json-tenant",
-                logLevel: "warn",
-            }));
-            const result = loadConfigFile(filePath);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("json-tenant");
-                expect(result.value.logLevel).toBe("warn");
-            }
-        });
-        it("returns FILE_NOT_FOUND for non-existent file", () => {
-            const result = loadConfigFile("/does/not/exist/config.yaml");
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("FILE_NOT_FOUND");
-                expect(result.error.path).toContain("/does/not/exist/config.yaml");
-            }
-        });
-        it("returns PARSE_ERROR for invalid YAML", () => {
-            const dir = makeTmpDir();
-            const filePath = writeFile(dir, "bad.yaml", "{ invalid: yaml: content: [}");
-            const result = loadConfigFile(filePath);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("PARSE_ERROR");
-            }
-        });
-        it("returns empty object for empty file", () => {
-            const dir = makeTmpDir();
-            const filePath = writeFile(dir, "empty.yaml", "");
-            const result = loadConfigFile(filePath);
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toEqual({});
-            }
-        });
-        it("returns PARSE_ERROR for array root", () => {
-            const dir = makeTmpDir();
-            const filePath = writeFile(dir, "array.yaml", "- one\n- two\n");
-            const result = loadConfigFile(filePath);
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("PARSE_ERROR");
-                expect(result.error.message).toContain("array");
-            }
-        });
-    });
-    describe("validateConfig", () => {
-        it("validates minimal config with all defaults applied", () => {
-            const result = validateConfig({});
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("default");
-                expect(result.value.logLevel).toBe("info");
-                expect(result.value.dataDir).toBe("");
-                expect(result.value.agents.default.name).toBe("Comis");
-                expect(result.value.agents.default.model).toBe("default");
-                expect(result.value.agents.default.maxSteps).toBe(150);
-                expect(result.value.memory.walMode).toBe(true);
-                expect(result.value.security.logRedaction).toBe(true);
-            }
-        });
-        it("applies partial overrides with defaults for missing fields", () => {
-            const result = validateConfig({
-                tenantId: "custom",
-                agents: { default: { name: "MyBot" } },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("custom");
-                expect(result.value.agents.default.name).toBe("MyBot");
-                // Defaults still applied
-                expect(result.value.agents.default.model).toBe("default");
-                expect(result.value.logLevel).toBe("info");
-            }
-        });
-        it("rejects invalid log level", () => {
-            const result = validateConfig({ logLevel: "verbose" });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("VALIDATION_ERROR");
-                expect(result.error.message).toContain("logLevel");
-            }
-        });
-        it("rejects invalid types (string where number expected)", () => {
-            const result = validateConfig({
-                agents: { default: { maxSteps: "not-a-number" } },
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("VALIDATION_ERROR");
-            }
-        });
-        it("rejects unknown top-level fields (strict mode)", () => {
-            const result = validateConfig({ unknownField: true });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("VALIDATION_ERROR");
-            }
-        });
-        it("validates full config with all sections", () => {
-            const result = validateConfig({
-                tenantId: "acme",
-                logLevel: "debug",
-                dataDir: "/var/comis",
-                agents: {
-                    default: {
-                        name: "AcmeBot",
-                        model: "gpt-4",
-                        provider: "openai",
-                        maxSteps: 50,
-                        budgets: {
-                            perExecution: 50_000,
-                            perHour: 200_000,
-                            perDay: 1_000_000,
-                        },
-                        circuitBreaker: {
-                            failureThreshold: 3,
-                            resetTimeoutMs: 30_000,
-                            halfOpenTimeoutMs: 15_000,
-                        },
-                    },
-                },
-                channels: {
-                    telegram: { enabled: true, botToken: "tok123", allowFrom: ["user1"] },
-                    discord: {},
-                    slack: {},
-                    whatsapp: {},
-                },
-                memory: {
-                    dbPath: "/var/comis/memory.db",
-                    walMode: true,
-                    embeddingModel: "text-embedding-3-small",
-                    embeddingDimensions: 1536,
-                    compaction: { enabled: true, threshold: 500, targetSize: 250 },
-                    retention: { maxAgeDays: 90, maxEntries: 10_000 },
-                },
-                security: {
-                    logRedaction: true,
-                    auditLog: true,
-                    permission: {
-                        enableNodePermissions: true,
-                        allowedFsPaths: ["/var/comis"],
-                        allowedNetHosts: ["api.anthropic.com"],
-                    },
-                    actionConfirmation: {
-                        requireForDestructive: true,
-                        requireForSensitive: true,
-                        autoApprove: ["read_file"],
-                    },
-                },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("acme");
-                expect(result.value.agents.default.budgets.perExecution).toBe(50_000);
-                expect(result.value.channels.telegram.enabled).toBe(true);
-                expect(result.value.memory.compaction.threshold).toBe(500);
-                expect(result.value.security.permission.enableNodePermissions).toBe(true);
-            }
-        });
-    });
-    describe("multi-agent config", () => {
-        it("validates agents: map with per-agent skills", () => {
-            const result = validateConfig({
-                agents: {
-                    dash: {
-                        name: "dash",
-                        provider: "anthropic",
-                        model: "claude-sonnet-4-5-20250929",
-                        skills: {
-                            toolPolicy: {
-                                profile: "full",
-                                deny: ["group:platform_actions"],
-                            },
-                            builtinTools: {
-                                read: true,
-                                write: true,
-                            },
-                        },
-                    },
-                    coder: {
-                        name: "coder",
-                        provider: "anthropic",
-                        model: "claude-sonnet-4-5-20250929",
-                        skills: {
-                            toolPolicy: {
-                                profile: "coding",
-                            },
-                            builtinTools: {
-                                read: true,
-                                edit: true,
-                            },
-                        },
-                    },
-                },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.agents.dash.skills?.toolPolicy.profile).toBe("full");
-                expect(result.value.agents.dash.skills?.toolPolicy.deny).toEqual(["group:platform_actions"]);
-                expect(result.value.agents.dash.skills?.builtinTools.read).toBe(true);
-                expect(result.value.agents.coder.skills?.toolPolicy.profile).toBe("coding");
-                expect(result.value.agents.coder.skills?.builtinTools.read).toBe(true);
-                expect(result.value.agents.coder.skills?.builtinTools.edit).toBe(true);
-            }
-        });
-        it("per-agent skills block is optional", () => {
-            const result = validateConfig({
-                agents: {
-                    withSkills: {
-                        name: "WithSkills",
-                        skills: {
-                            toolPolicy: { profile: "full" },
-                        },
-                    },
-                    withoutSkills: {
-                        name: "WithoutSkills",
-                    },
-                },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.agents.withSkills.skills).toBeDefined();
-                expect(result.value.agents.withSkills.skills?.toolPolicy.profile).toBe("full");
-                expect(result.value.agents.withoutSkills.skills).toBeUndefined();
-            }
-        });
-        it("empty config produces default agents map", () => {
-            const result = validateConfig({});
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.agents.default).toBeDefined();
-                expect(result.value.agents.default.name).toBe("Comis");
-                expect(result.value.agents.default.model).toBe("default");
-                expect(result.value.agents.default.provider).toBe("default");
-            }
-        });
-        it("rejects old singular agent: key", () => {
-            const result = validateConfig({ agent: { name: "TestBot" } });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("VALIDATION_ERROR");
-            }
-        });
-        it("rejects old global skills: key", () => {
-            const result = validateConfig({ skills: { toolPolicy: { profile: "full" } } });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("VALIDATION_ERROR");
-            }
-        });
-    });
-});

package/node_modules/@comis/core/dist/config/migrate.test.d.ts

@@ -1 +0,0 @@
-export {};