comisai 1.0.11 → 1.0.13

package/node_modules/@comis/core/dist/config/schema-sender-trust-display.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { SenderTrustDisplayConfigSchema } from "./schema-sender-trust-display.js";
-describe("SenderTrustDisplayConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = SenderTrustDisplayConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(false);
-            expect(result.data.displayMode).toBe("hash");
-            expect(result.data.hashPrefix).toBe(8);
-            expect(result.data.hashSecretRef).toBe("");
-            expect(result.data.aliases).toEqual({});
-        }
-    });
-    it("accepts fully specified config", () => {
-        const result = SenderTrustDisplayConfigSchema.safeParse({
-            enabled: true,
-            displayMode: "alias",
-            hashPrefix: 12,
-            hashSecretRef: "secrets/hmac-key",
-            aliases: {
-                "user-123": "Alice",
-                "user-456": "Bob",
-            },
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(true);
-            expect(result.data.displayMode).toBe("alias");
-            expect(result.data.hashPrefix).toBe(12);
-            expect(result.data.hashSecretRef).toBe("secrets/hmac-key");
-            expect(result.data.aliases["user-123"]).toBe("Alice");
-        }
-    });
-    it("rejects unknown keys (strictObject)", () => {
-        const result = SenderTrustDisplayConfigSchema.safeParse({
-            enabled: true,
-            unknownField: "should-fail",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid displayMode enum value", () => {
-        const result = SenderTrustDisplayConfigSchema.safeParse({
-            displayMode: "obfuscated",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects hashPrefix below minimum (4)", () => {
-        const result = SenderTrustDisplayConfigSchema.safeParse({
-            hashPrefix: 3,
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects hashPrefix above maximum (16)", () => {
-        const result = SenderTrustDisplayConfigSchema.safeParse({
-            hashPrefix: 17,
-        });
-        expect(result.success).toBe(false);
-    });
-});

package/node_modules/@comis/core/dist/config/schema-serializer.test.d.ts

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

package/node_modules/@comis/core/dist/config/schema-serializer.test.js

@@ -1,73 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getConfigSchema, getConfigSections } from "./schema-serializer.js";
-describe("getConfigSchema", () => {
-    it("returns full schema with type property", () => {
-        const schema = getConfigSchema();
-        expect(schema).toBeDefined();
-        expect(typeof schema).toBe("object");
-        // JSON Schema always has a type or definitions at the top level
-        expect(schema).toHaveProperty("type");
-    });
-    it("caches the full schema (same reference on second call)", () => {
-        const first = getConfigSchema();
-        const second = getConfigSchema();
-        expect(first).toBe(second);
-    });
-    it("returns section-specific schema for agents", () => {
-        const schema = getConfigSchema("agents");
-        expect(schema).toBeDefined();
-        expect(typeof schema).toBe("object");
-        expect(schema).toHaveProperty("type");
-    });
-    it("returns section-specific schema for gateway", () => {
-        const schema = getConfigSchema("gateway");
-        expect(schema).toBeDefined();
-        expect(typeof schema).toBe("object");
-        expect(schema).toHaveProperty("type");
-    });
-    it("throws for unknown section name", () => {
-        expect(() => getConfigSchema("unknown_section")).toThrow("Unknown config section: unknown_section");
-    });
-    it("throws for empty string section", () => {
-        expect(() => getConfigSchema("")).toThrow("Unknown config section: ");
-    });
-    it("getConfigSchema('agents') returns JSON Schema for per-agent config", () => {
-        const schema = getConfigSchema("agents");
-        expect(schema).toHaveProperty("type");
-        // PerAgentConfigSchema is an object type with agent properties
-        expect(schema.type).toBe("object");
-        const sections = getConfigSections();
-        expect(sections).toContain("agents");
-    });
-});
-describe("getConfigSections", () => {
-    it("returns an array of section names", () => {
-        const sections = getConfigSections();
-        expect(Array.isArray(sections)).toBe(true);
-        expect(sections.length).toBeGreaterThan(0);
-    });
-    it("contains agents, security, and gateway", () => {
-        const sections = getConfigSections();
-        expect(sections).toContain("agents");
-        expect(sections).toContain("security");
-        expect(sections).toContain("gateway");
-    });
-    it("contains all 15 sections", () => {
-        const sections = getConfigSections();
-        expect(sections).toHaveLength(15);
-        expect(sections).toContain("agents");
-        expect(sections).toContain("channels");
-        expect(sections).toContain("memory");
-        expect(sections).toContain("routing");
-        expect(sections).toContain("daemon");
-        expect(sections).toContain("scheduler");
-        expect(sections).toContain("integrations");
-        expect(sections).toContain("monitoring");
-        // CFG-07: New config sections
-        expect(sections).toContain("browser");
-        expect(sections).toContain("models");
-        expect(sections).toContain("providers");
-        expect(sections).toContain("messages");
-        expect(sections).toContain("approvals");
-    });
-});

package/node_modules/@comis/core/dist/config/schema-telegram-file-guard.test.d.ts

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

package/node_modules/@comis/core/dist/config/schema-telegram-file-guard.test.js

@@ -1,39 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { TelegramFileRefGuardConfigSchema } from "./schema-telegram-file-guard.js";
-describe("TelegramFileRefGuardConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = TelegramFileRefGuardConfigSchema.safeParse({});
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(true);
-            expect(result.data.additionalExtensions).toEqual([]);
-            expect(result.data.excludedExtensions).toEqual([]);
-        }
-    });
-    it("accepts fully specified config", () => {
-        const result = TelegramFileRefGuardConfigSchema.safeParse({
-            enabled: false,
-            additionalExtensions: [".docx", ".xlsx"],
-            excludedExtensions: [".txt"],
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.enabled).toBe(false);
-            expect(result.data.additionalExtensions).toEqual([".docx", ".xlsx"]);
-            expect(result.data.excludedExtensions).toEqual([".txt"]);
-        }
-    });
-    it("rejects unknown keys (strictObject)", () => {
-        const result = TelegramFileRefGuardConfigSchema.safeParse({
-            enabled: true,
-            unknownField: "should-fail",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects non-array additionalExtensions", () => {
-        const result = TelegramFileRefGuardConfigSchema.safeParse({
-            additionalExtensions: ".docx",
-        });
-        expect(result.success).toBe(false);
-    });
-});

package/node_modules/@comis/core/dist/context/context.test.d.ts

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

package/node_modules/@comis/core/dist/context/context.test.js

@@ -1,276 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { describe, it, expect } from "vitest";
-import { RequestContextSchema, getContext, tryGetContext, runWithContext } from "./context.js";
-function makeContext(overrides = {}) {
-    return {
-        tenantId: "tenant-1",
-        userId: "user-1",
-        sessionKey: "tenant-1:user-1:chan-1",
-        traceId: randomUUID(),
-        startedAt: Date.now(),
-        trustLevel: "user",
-        ...overrides,
-    };
-}
-describe("RequestContext", () => {
-    describe("runWithContext + getContext", () => {
-        it("returns context within scope", () => {
-            const ctx = makeContext();
-            const result = runWithContext(ctx, () => getContext());
-            expect(result).toEqual(ctx);
-        });
-        it("returns the exact same context object", () => {
-            const ctx = makeContext();
-            runWithContext(ctx, () => {
-                const retrieved = getContext();
-                expect(retrieved).toBe(ctx);
-            });
-        });
-    });
-    describe("getContext outside scope", () => {
-        it("throws descriptive error", () => {
-            expect(() => getContext()).toThrow("getContext() called outside of a request context scope");
-        });
-        it("error message mentions runWithContext", () => {
-            expect(() => getContext()).toThrow("runWithContext()");
-        });
-        it("error message mentions tryGetContext alternative", () => {
-            expect(() => getContext()).toThrow("tryGetContext()");
-        });
-    });
-    describe("tryGetContext", () => {
-        it("returns undefined outside scope", () => {
-            expect(tryGetContext()).toBeUndefined();
-        });
-        it("returns context within scope", () => {
-            const ctx = makeContext();
-            runWithContext(ctx, () => {
-                expect(tryGetContext()).toEqual(ctx);
-            });
-        });
-    });
-    describe("async propagation", () => {
-        it("context propagates through async/await", async () => {
-            const ctx = makeContext();
-            const result = await runWithContext(ctx, async () => {
-                // Simulate async work
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                return getContext();
-            });
-            expect(result).toEqual(ctx);
-        });
-        it("context propagates through multiple async hops", async () => {
-            const ctx = makeContext();
-            async function innerAsync() {
-                await new Promise((resolve) => setTimeout(resolve, 5));
-                return getContext();
-            }
-            const result = await runWithContext(ctx, async () => {
-                await new Promise((resolve) => setTimeout(resolve, 5));
-                return innerAsync();
-            });
-            expect(result.traceId).toBe(ctx.traceId);
-        });
-    });
-    describe("nested scopes", () => {
-        it("nested runWithContext creates independent scopes", () => {
-            const outerCtx = makeContext({ tenantId: "outer" });
-            const innerCtx = makeContext({ tenantId: "inner" });
-            runWithContext(outerCtx, () => {
-                expect(getContext().tenantId).toBe("outer");
-                runWithContext(innerCtx, () => {
-                    expect(getContext().tenantId).toBe("inner");
-                });
-                // Outer context restored after inner scope exits
-                expect(getContext().tenantId).toBe("outer");
-            });
-        });
-    });
-    describe("concurrent isolation", () => {
-        it("concurrent contexts maintain isolation via Promise.all", async () => {
-            const ctx1 = makeContext({ tenantId: "tenant-A", userId: "user-A" });
-            const ctx2 = makeContext({ tenantId: "tenant-B", userId: "user-B" });
-            const ctx3 = makeContext({ tenantId: "tenant-C", userId: "user-C" });
-            const [result1, result2, result3] = await Promise.all([
-                runWithContext(ctx1, async () => {
-                    await new Promise((resolve) => setTimeout(resolve, 15));
-                    return getContext().tenantId;
-                }),
-                runWithContext(ctx2, async () => {
-                    await new Promise((resolve) => setTimeout(resolve, 10));
-                    return getContext().tenantId;
-                }),
-                runWithContext(ctx3, async () => {
-                    await new Promise((resolve) => setTimeout(resolve, 5));
-                    return getContext().tenantId;
-                }),
-            ]);
-            expect(result1).toBe("tenant-A");
-            expect(result2).toBe("tenant-B");
-            expect(result3).toBe("tenant-C");
-        });
-    });
-    describe("RequestContextSchema", () => {
-        it("validates correct context", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-            });
-            expect(result.success).toBe(true);
-        });
-        it("tenantId defaults to 'default'", () => {
-            const result = RequestContextSchema.parse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-            });
-            expect(result.tenantId).toBe("default");
-        });
-        it("rejects missing required fields", () => {
-            const result = RequestContextSchema.safeParse({
-                tenantId: "t1",
-            });
-            expect(result.success).toBe(false);
-        });
-        it("rejects invalid traceId format", () => {
-            const result = RequestContextSchema.safeParse({
-                tenantId: "t1",
-                userId: "u1",
-                sessionKey: "t1:u1:c1",
-                traceId: "not-a-uuid",
-                startedAt: Date.now(),
-            });
-            expect(result.success).toBe(false);
-        });
-        it("rejects unknown fields (strict mode)", () => {
-            const result = RequestContextSchema.safeParse({
-                tenantId: "t1",
-                userId: "u1",
-                sessionKey: "t1:u1:c1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-                extraField: "should-fail",
-            });
-            expect(result.success).toBe(false);
-        });
-    });
-    describe("trustLevel", () => {
-        it("trustLevel defaults to 'admin'", () => {
-            const result = RequestContextSchema.parse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-            });
-            expect(result.trustLevel).toBe("admin");
-        });
-        it("accepts admin trustLevel", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-                trustLevel: "admin",
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.trustLevel).toBe("admin");
-            }
-        });
-        it("accepts guest trustLevel", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-                trustLevel: "guest",
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.trustLevel).toBe("guest");
-            }
-        });
-        it("rejects invalid trustLevel", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-                trustLevel: "superadmin",
-            });
-            expect(result.success).toBe(false);
-        });
-    });
-    describe("contentDelimiter", () => {
-        it("accepts optional contentDelimiter field", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-                contentDelimiter: "abcdef0123456789abcdef01",
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.contentDelimiter).toBe("abcdef0123456789abcdef01");
-            }
-        });
-        it("context without contentDelimiter still parses (backward compat)", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.contentDelimiter).toBeUndefined();
-            }
-        });
-        it("rejects contentDelimiter shorter than 16 chars", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-                contentDelimiter: "short",
-            });
-            expect(result.success).toBe(false);
-        });
-    });
-    describe("channelType", () => {
-        it("accepts optional channelType field", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-                channelType: "telegram",
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.channelType).toBe("telegram");
-            }
-        });
-        it("context without channelType still parses (backward compat)", () => {
-            const result = RequestContextSchema.safeParse({
-                userId: "user-1",
-                sessionKey: "default:user-1:chan-1",
-                traceId: randomUUID(),
-                startedAt: Date.now(),
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.channelType).toBeUndefined();
-            }
-        });
-        it("channelType propagates through runWithContext", () => {
-            const ctx = makeContext({ channelType: "discord" });
-            const result = runWithContext(ctx, () => getContext());
-            expect(result.channelType).toBe("discord");
-        });
-    });
-});

package/node_modules/@comis/core/dist/domain/agent-response.test.d.ts

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

package/node_modules/@comis/core/dist/domain/agent-response.test.js

@@ -1,159 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseAgentResponse } from "./agent-response.js";
-function validResponse(overrides = {}) {
-    return {
-        agentId: "main-agent",
-        content: "Here is my response.",
-        ...overrides,
-    };
-}
-describe("AgentResponse", () => {
-    describe("valid data", () => {
-        it("parses a minimal valid response", () => {
-            const result = parseAgentResponse(validResponse());
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.agentId).toBe("main-agent");
-                expect(result.value.content).toBe("Here is my response.");
-            }
-        });
-        it("applies default values for toolCalls, finishReason, metadata", () => {
-            const result = parseAgentResponse(validResponse());
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.toolCalls).toEqual([]);
-                expect(result.value.finishReason).toBe("stop");
-                expect(result.value.metadata).toEqual({});
-            }
-        });
-        it("accepts empty content (agent may return only tool calls)", () => {
-            const result = parseAgentResponse(validResponse({ content: "" }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.content).toBe("");
-            }
-        });
-        it("accepts all finish reasons", () => {
-            const reasons = ["stop", "max_tokens", "tool_use", "error", "budget_exceeded"];
-            for (const finishReason of reasons) {
-                const result = parseAgentResponse(validResponse({ finishReason }));
-                expect(result.ok).toBe(true);
-            }
-        });
-        it("accepts tool calls array", () => {
-            const result = parseAgentResponse(validResponse({
-                toolCalls: [
-                    { id: "tc-1", name: "search", input: { query: "test" } },
-                    { id: "tc-2", name: "read_file", input: { path: "/tmp/a.txt" } },
-                ],
-            }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.toolCalls).toHaveLength(2);
-                expect(result.value.toolCalls[0].name).toBe("search");
-            }
-        });
-        it("accepts tokensUsed when provided", () => {
-            const result = parseAgentResponse(validResponse({
-                tokensUsed: {
-                    prompt: 100,
-                    completion: 50,
-                    provider: "anthropic",
-                    model: "claude-opus-4-20250514",
-                },
-            }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tokensUsed?.prompt).toBe(100);
-                expect(result.value.tokensUsed?.provider).toBe("anthropic");
-            }
-        });
-        it("allows omitting optional tokensUsed", () => {
-            const result = parseAgentResponse(validResponse());
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tokensUsed).toBeUndefined();
-            }
-        });
-        it("accepts metadata with arbitrary values", () => {
-            const result = parseAgentResponse(validResponse({
-                metadata: { latencyMs: 234, cached: false },
-            }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.metadata).toEqual({
-                    latencyMs: 234,
-                    cached: false,
-                });
-            }
-        });
-    });
-    describe("invalid data", () => {
-        it("rejects missing required fields", () => {
-            const result = parseAgentResponse({});
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                const paths = result.error.issues.map((i) => i.path[0]);
-                expect(paths).toContain("agentId");
-                expect(paths).toContain("content");
-            }
-        });
-        it("rejects empty agentId", () => {
-            const result = parseAgentResponse(validResponse({ agentId: "" }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects invalid finishReason", () => {
-            const result = parseAgentResponse(validResponse({ finishReason: "cancelled" }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects invalid tool call shape", () => {
-            const result = parseAgentResponse(validResponse({ toolCalls: [{ bad: "shape" }] }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects tool call with empty id", () => {
-            const result = parseAgentResponse(validResponse({
-                toolCalls: [{ id: "", name: "search", input: {} }],
-            }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects tool call with empty name", () => {
-            const result = parseAgentResponse(validResponse({
-                toolCalls: [{ id: "tc-1", name: "", input: {} }],
-            }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects invalid tokensUsed shape", () => {
-            const result = parseAgentResponse(validResponse({ tokensUsed: { prompt: "not a number" } }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects negative token counts", () => {
-            const result = parseAgentResponse(validResponse({
-                tokensUsed: {
-                    prompt: -1,
-                    completion: 50,
-                    provider: "openai",
-                    model: "gpt-4",
-                },
-            }));
-            expect(result.ok).toBe(false);
-        });
-        it("strips extra/unknown fields", () => {
-            const result = parseAgentResponse(validResponse({ unknownField: "surprise" }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects non-object input", () => {
-            const result = parseAgentResponse(42);
-            expect(result.ok).toBe(false);
-        });
-        it("returns descriptive ZodError issues", () => {
-            const result = parseAgentResponse({ agentId: 123 });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.issues.length).toBeGreaterThan(0);
-                for (const issue of result.error.issues) {
-                    expect(issue.message).toBeTruthy();
-                }
-            }
-        });
-    });
-});

package/node_modules/@comis/core/dist/domain/credential-mapping.test.d.ts

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