comisai 1.0.10 → 1.0.12

package/node_modules/@comis/core/dist/security/action-classifier.test.js

@@ -1,298 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { classifyAction, requiresConfirmation, registerAction, lockRegistry, isRegistryLocked, _resetRegistryForTesting, } from "./action-classifier.js";
-describe("classifyAction", () => {
-    describe("read actions", () => {
-        const readActions = [
-            "file.read",
-            "memory.search",
-            "memory.get",
-            "config.read",
-            "status.check",
-            "skill.list",
-        ];
-        for (const action of readActions) {
-            it(`classifies "${action}" as read`, () => {
-                expect(classifyAction(action)).toBe("read");
-            });
-        }
-    });
-    describe("mutate actions", () => {
-        const mutateActions = [
-            "file.write",
-            "file.create",
-            "memory.store",
-            "memory.update",
-            "config.update",
-            "message.send",
-        ];
-        for (const action of mutateActions) {
-            it(`classifies "${action}" as mutate`, () => {
-                expect(classifyAction(action)).toBe("mutate");
-            });
-        }
-    });
-    describe("destructive actions", () => {
-        const destructiveActions = [
-            "file.delete",
-            "memory.delete",
-            "memory.clear",
-            "session.destroy",
-            "system.exec",
-            "system.shutdown",
-        ];
-        for (const action of destructiveActions) {
-            it(`classifies "${action}" as destructive`, () => {
-                expect(classifyAction(action)).toBe("destructive");
-            });
-        }
-    });
-    describe("v2.0 tool read actions", () => {
-        const v2ReadActions = [
-            "tool.execute",
-            "cron.list",
-            "cron.status",
-            "cron.runs",
-            "cron.wake",
-            "session.list",
-            "session.history",
-            "session.status",
-            "message.fetch",
-            "agents.list",
-            "gateway.status",
-            "config.schema",
-            "web.fetch",
-            "web.search",
-            "image.analyze",
-            "memory.search_files",
-            "memory.get_file",
-        ];
-        for (const action of v2ReadActions) {
-            it(`classifies "${action}" as read`, () => {
-                expect(classifyAction(action)).toBe("read");
-            });
-        }
-    });
-    describe("v2.0 tool mutate actions", () => {
-        const v2MutateActions = [
-            "message.reply",
-            "message.react",
-            "message.edit",
-            "cron.add",
-            "cron.update",
-            "session.send",
-            "session.spawn",
-            "tts.synthesize",
-            "canvas.present",
-            "canvas.eval",
-        ];
-        for (const action of v2MutateActions) {
-            it(`classifies "${action}" as mutate`, () => {
-                expect(classifyAction(action)).toBe("mutate");
-            });
-        }
-    });
-    describe("v2.0 tool destructive actions", () => {
-        const v2DestructiveActions = [
-            "cron.remove",
-            "message.delete",
-            "gateway.restart",
-            "gateway.update",
-            "config.patch",
-            "config.apply",
-        ];
-        it('classifies "config.patch" as destructive (CFGSAFE-01)', () => {
-            expect(classifyAction("config.patch")).toBe("destructive");
-        });
-        it('classifies "config.apply" as destructive (CFGAPPLY-01)', () => {
-            expect(classifyAction("config.apply")).toBe("destructive");
-        });
-        for (const action of v2DestructiveActions) {
-            it(`classifies "${action}" as destructive`, () => {
-                expect(classifyAction(action)).toBe("destructive");
-            });
-        }
-    });
-    describe("v23.0 config management actions", () => {
-        it('classifies "config.history" as read', () => {
-            expect(classifyAction("config.history")).toBe("read");
-        });
-        it('classifies "config.diff" as read', () => {
-            expect(classifyAction("config.diff")).toBe("read");
-        });
-        it('classifies "config.rollback" as destructive', () => {
-            expect(classifyAction("config.rollback")).toBe("destructive");
-        });
-        it('classifies "config.apply" as destructive', () => {
-            expect(classifyAction("config.apply")).toBe("destructive");
-        });
-        it('classifies "config.gc" as destructive', () => {
-            expect(classifyAction("config.gc")).toBe("destructive");
-        });
-        it('classifies "daemon.setLogLevel" as mutate (in-memory only, resets on restart)', () => {
-            expect(classifyAction("daemon.setLogLevel")).toBe("mutate");
-        });
-    });
-    describe("v6.5 prompt skill actions", () => {
-        it('classifies "skill.prompt.load" as read', () => {
-            expect(classifyAction("skill.prompt.load")).toBe("read");
-        });
-        it('classifies "skill.prompt.invoke" as mutate', () => {
-            expect(classifyAction("skill.prompt.invoke")).toBe("mutate");
-        });
-    });
-    describe("v22.0 privileged tool actions", () => {
-        describe("read actions", () => {
-            const readActions = [
-                "agents.get",
-                "session.export",
-                "memory.stats",
-                "memory.browse",
-                "memory.export",
-                "channels.list",
-                "channels.get",
-                "tokens.list",
-                "models.list",
-                "models.test",
-            ];
-            for (const action of readActions) {
-                it(`classifies "${action}" as read`, () => {
-                    expect(classifyAction(action)).toBe("read");
-                });
-            }
-        });
-        describe("mutate actions", () => {
-            const mutateActions = ["agents.update", "agents.resume"];
-            for (const action of mutateActions) {
-                it(`classifies "${action}" as mutate`, () => {
-                    expect(classifyAction(action)).toBe("mutate");
-                });
-            }
-        });
-        describe("destructive actions", () => {
-            const destructiveActions = [
-                "agents.create",
-                "agents.delete",
-                "agents.suspend",
-                "session.delete",
-                "memory.flush",
-                "channels.enable",
-                "channels.disable",
-                "channels.restart",
-                "tokens.create",
-                "tokens.revoke",
-                "tokens.rotate",
-            ];
-            for (const action of destructiveActions) {
-                it(`classifies "${action}" as destructive`, () => {
-                    expect(classifyAction(action)).toBe("destructive");
-                });
-            }
-        });
-    });
-    describe("unknown actions", () => {
-        it("defaults unknown action to destructive (fail-closed)", () => {
-            expect(classifyAction("totally.unknown.action")).toBe("destructive");
-        });
-        it("defaults empty string to destructive", () => {
-            expect(classifyAction("")).toBe("destructive");
-        });
-        it("defaults novel action to destructive", () => {
-            expect(classifyAction("custom.plugin.run")).toBe("destructive");
-        });
-    });
-});
-describe("requiresConfirmation", () => {
-    it("returns true for destructive actions", () => {
-        expect(requiresConfirmation("file.delete")).toBe(true);
-        expect(requiresConfirmation("system.exec")).toBe(true);
-    });
-    it("returns true for unknown actions (fail-closed)", () => {
-        expect(requiresConfirmation("unknown.action")).toBe(true);
-    });
-    it("returns false for read actions", () => {
-        expect(requiresConfirmation("file.read")).toBe(false);
-        expect(requiresConfirmation("memory.search")).toBe(false);
-    });
-    it("returns false for mutate actions", () => {
-        expect(requiresConfirmation("file.write")).toBe(false);
-        expect(requiresConfirmation("message.send")).toBe(false);
-    });
-    it("requires confirmation for config.patch (CFGSAFE-01)", () => {
-        expect(requiresConfirmation("config.patch")).toBe(true);
-    });
-});
-describe("requiresConfirmation - v23.0 daemon actions", () => {
-    it("returns false for daemon.setLogLevel (mutate, not destructive)", () => {
-        expect(requiresConfirmation("daemon.setLogLevel")).toBe(false);
-    });
-    it("returns true for config.rollback (destructive)", () => {
-        expect(requiresConfirmation("config.rollback")).toBe(true);
-    });
-    it("returns true for config.gc (destructive)", () => {
-        expect(requiresConfirmation("config.gc")).toBe(true);
-    });
-});
-describe("requiresConfirmation - v22.0 privileged actions", () => {
-    it("returns true for destructive privileged actions", () => {
-        expect(requiresConfirmation("agents.create")).toBe(true);
-        expect(requiresConfirmation("agents.delete")).toBe(true);
-        expect(requiresConfirmation("tokens.revoke")).toBe(true);
-        expect(requiresConfirmation("channels.restart")).toBe(true);
-    });
-    it("returns false for read privileged actions", () => {
-        expect(requiresConfirmation("agents.get")).toBe(false);
-        expect(requiresConfirmation("models.list")).toBe(false);
-        expect(requiresConfirmation("channels.list")).toBe(false);
-    });
-});
-describe("registerAction", () => {
-    it("registers a new action type", () => {
-        registerAction("custom.read", "read");
-        expect(classifyAction("custom.read")).toBe("read");
-    });
-    it("overwrites an existing registration", () => {
-        registerAction("custom.overwrite", "destructive");
-        expect(classifyAction("custom.overwrite")).toBe("destructive");
-        registerAction("custom.overwrite", "read");
-        expect(classifyAction("custom.overwrite")).toBe("read");
-    });
-    it("accepts all valid classifications", () => {
-        const classifications = ["read", "mutate", "destructive"];
-        for (const classification of classifications) {
-            registerAction(`test.${classification}`, classification);
-            expect(classifyAction(`test.${classification}`)).toBe(classification);
-        }
-    });
-});
-describe("lockRegistry (CORE-01)", () => {
-    beforeEach(() => {
-        _resetRegistryForTesting();
-    });
-    it("lockRegistry prevents subsequent registerAction calls", () => {
-        lockRegistry();
-        expect(() => registerAction("new.action", "read")).toThrow("locked");
-    });
-    it("isRegistryLocked returns true after locking", () => {
-        expect(isRegistryLocked()).toBe(false);
-        lockRegistry();
-        expect(isRegistryLocked()).toBe(true);
-    });
-    it("classifyAction still works after locking", () => {
-        lockRegistry();
-        // Pre-registered actions should still work
-        expect(classifyAction("file.read")).toBe("read");
-        expect(classifyAction("file.write")).toBe("mutate");
-        expect(classifyAction("file.delete")).toBe("destructive");
-        // Unknown actions still default to destructive
-        expect(classifyAction("totally.unknown")).toBe("destructive");
-    });
-    it("lockRegistry is idempotent", () => {
-        lockRegistry();
-        lockRegistry(); // second call should not throw
-        expect(isRegistryLocked()).toBe(true);
-    });
-    it("registerAction error message includes the rejected action type", () => {
-        lockRegistry();
-        expect(() => registerAction("malicious.downgrade", "read")).toThrow('registerAction() rejected for "malicious.downgrade"');
-    });
-});

package/node_modules/@comis/core/dist/security/audit-aggregator.test.d.ts

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

package/node_modules/@comis/core/dist/security/audit-aggregator.test.js

@@ -1,128 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createAuditAggregator } from "./audit-aggregator.js";
-function createMockEventBus() {
-    return { emit: vi.fn(), on: vi.fn(), off: vi.fn() };
-}
-describe("createAuditAggregator", () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it("deduplicates events within window", () => {
-        const eventBus = createMockEventBus();
-        const aggregator = createAuditAggregator(eventBus, { windowMs: 5000 });
-        aggregator.record({ source: "external_content", patterns: ["a"] });
-        aggregator.record({ source: "external_content", patterns: ["b"] });
-        aggregator.record({ source: "external_content", patterns: ["c"] });
-        // Not yet emitted
-        expect(eventBus.emit).not.toHaveBeenCalled();
-        // Advance past window
-        vi.advanceTimersByTime(5001);
-        // Should emit exactly once (deduplicated)
-        expect(eventBus.emit).toHaveBeenCalledTimes(1);
-    });
-    it("emits summary at window close with correct payload", () => {
-        const eventBus = createMockEventBus();
-        const aggregator = createAuditAggregator(eventBus, { windowMs: 5000 });
-        aggregator.record({ source: "external_content", patterns: ["pattern_a"] });
-        aggregator.record({ source: "external_content", patterns: ["pattern_b"] });
-        vi.advanceTimersByTime(5001);
-        expect(eventBus.emit).toHaveBeenCalledTimes(1);
-        const [eventName, payload] = eventBus.emit.mock.calls[0];
-        expect(eventName).toBe("security:injection_detected");
-        expect(payload.source).toBe("external_content");
-        expect(payload.riskLevel).toBe("medium");
-        expect(payload.patterns).toContain("pattern_a");
-        expect(payload.patterns).toContain("pattern_b");
-        expect(typeof payload.timestamp).toBe("number");
-    });
-    it("counts unique patterns", () => {
-        const eventBus = createMockEventBus();
-        const aggregator = createAuditAggregator(eventBus, { windowMs: 5000 });
-        aggregator.record({ source: "external_content", patterns: ["a", "b"] });
-        aggregator.record({ source: "external_content", patterns: ["b", "c"] });
-        vi.advanceTimersByTime(5001);
-        const [, payload] = eventBus.emit.mock.calls[0];
-        // Should have 3 unique patterns: a, b, c
-        expect(payload.patterns).toHaveLength(3);
-        expect(payload.patterns).toContain("a");
-        expect(payload.patterns).toContain("b");
-        expect(payload.patterns).toContain("c");
-    });
-    it("respects maxPatternsPerSummary cap", () => {
-        const eventBus = createMockEventBus();
-        const aggregator = createAuditAggregator(eventBus, {
-            windowMs: 5000,
-            maxPatternsPerSummary: 2,
-        });
-        aggregator.record({
-            source: "external_content",
-            patterns: ["a", "b", "c", "d", "e"],
-        });
-        vi.advanceTimersByTime(5001);
-        const [, payload] = eventBus.emit.mock.calls[0];
-        expect(payload.patterns).toHaveLength(2);
-    });
-    it("handles multiple concurrent windows for different sources", () => {
-        const eventBus = createMockEventBus();
-        const aggregator = createAuditAggregator(eventBus, { windowMs: 5000 });
-        aggregator.record({ source: "external_content", patterns: ["a"] });
-        aggregator.record({ source: "tool_output", patterns: ["b"] });
-        vi.advanceTimersByTime(5001);
-        // Two separate summary events -- one per source
-        expect(eventBus.emit).toHaveBeenCalledTimes(2);
-        const sources = eventBus.emit.mock.calls.map((call) => call[0]);
-        expect(sources).toEqual([
-            "security:injection_detected",
-            "security:injection_detected",
-        ]);
-    });
-    it("flush() emits all pending windows immediately", () => {
-        const eventBus = createMockEventBus();
-        const aggregator = createAuditAggregator(eventBus, { windowMs: 60_000 });
-        aggregator.record({ source: "external_content", patterns: ["a"] });
-        aggregator.record({ source: "tool_output", patterns: ["b"] });
-        // Flush without advancing timers
-        aggregator.flush();
-        expect(eventBus.emit).toHaveBeenCalledTimes(2);
-    });
-    it("destroy() clears all timers without emitting", () => {
-        const eventBus = createMockEventBus();
-        const aggregator = createAuditAggregator(eventBus, { windowMs: 5000 });
-        aggregator.record({ source: "external_content", patterns: ["a"] });
-        aggregator.record({ source: "tool_output", patterns: ["b"] });
-        aggregator.destroy();
-        // Advance past window -- nothing should emit
-        vi.advanceTimersByTime(10_000);
-        expect(eventBus.emit).not.toHaveBeenCalled();
-    });
-    it("OBS-06: logs INFO summary at window close", () => {
-        const eventBus = createMockEventBus();
-        const mockLogger = { info: vi.fn() };
-        const aggregator = createAuditAggregator(eventBus, { windowMs: 5000 }, mockLogger);
-        aggregator.record({ source: "external_content", patterns: ["x"] });
-        aggregator.record({ source: "external_content", patterns: ["y"] });
-        aggregator.record({ source: "external_content", patterns: ["z"] });
-        vi.advanceTimersByTime(5001);
-        expect(mockLogger.info).toHaveBeenCalledTimes(1);
-        const [logObj, logMsg] = mockLogger.info.mock.calls[0];
-        expect(logObj.eventCount).toBe(3);
-        expect(logObj.uniquePatterns).toBe(3);
-        expect(logObj.suppressedCount).toBe(2); // 3 - 1 = 2
-        expect(logObj.windowKey).toBe("external_content");
-        expect(logMsg).toBe("Audit aggregation window closed");
-    });
-    it("accepts new events after window closes for same source", () => {
-        const eventBus = createMockEventBus();
-        const aggregator = createAuditAggregator(eventBus, { windowMs: 5000 });
-        aggregator.record({ source: "external_content", patterns: ["a"] });
-        vi.advanceTimersByTime(5001);
-        expect(eventBus.emit).toHaveBeenCalledTimes(1);
-        // Record again after window closed
-        aggregator.record({ source: "external_content", patterns: ["b"] });
-        vi.advanceTimersByTime(5001);
-        expect(eventBus.emit).toHaveBeenCalledTimes(2);
-    });
-});

package/node_modules/@comis/core/dist/security/audit.test.d.ts

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

package/node_modules/@comis/core/dist/security/audit.test.js

@@ -1,154 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { AuditEventSchema, createAuditEvent } from "./audit.js";
-const VALID_PARAMS = {
-    tenantId: "tenant-1",
-    agentId: "agent-1",
-    userId: "user-1",
-    actionType: "file.read",
-    classification: "read",
-    outcome: "success",
-};
-describe("createAuditEvent", () => {
-    it("creates a valid audit event with auto-generated id and timestamp", () => {
-        const event = createAuditEvent(VALID_PARAMS);
-        expect(event.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-        expect(event.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
-        expect(event.tenantId).toBe("tenant-1");
-        expect(event.agentId).toBe("agent-1");
-        expect(event.userId).toBe("user-1");
-        expect(event.actionType).toBe("file.read");
-        expect(event.classification).toBe("read");
-        expect(event.outcome).toBe("success");
-    });
-    it("defaults metadata to empty object when not provided", () => {
-        const event = createAuditEvent(VALID_PARAMS);
-        expect(event.metadata).toEqual({});
-    });
-    it("includes metadata when provided", () => {
-        const event = createAuditEvent({
-            ...VALID_PARAMS,
-            metadata: { filePath: "/tmp/test.txt", size: 1024 },
-        });
-        expect(event.metadata).toEqual({ filePath: "/tmp/test.txt", size: 1024 });
-    });
-    it("includes optional traceId when provided", () => {
-        const event = createAuditEvent({
-            ...VALID_PARAMS,
-            traceId: "trace-abc-123",
-        });
-        expect(event.traceId).toBe("trace-abc-123");
-    });
-    it("includes optional duration when provided", () => {
-        const event = createAuditEvent({
-            ...VALID_PARAMS,
-            duration: 42.5,
-        });
-        expect(event.duration).toBe(42.5);
-    });
-    it("generates unique ids for each event", () => {
-        const event1 = createAuditEvent(VALID_PARAMS);
-        const event2 = createAuditEvent(VALID_PARAMS);
-        expect(event1.id).not.toBe(event2.id);
-    });
-    it("supports all classification types", () => {
-        for (const classification of ["read", "mutate", "destructive"]) {
-            const event = createAuditEvent({ ...VALID_PARAMS, classification });
-            expect(event.classification).toBe(classification);
-        }
-    });
-    it("supports all outcome types", () => {
-        for (const outcome of ["success", "failure", "denied"]) {
-            const event = createAuditEvent({ ...VALID_PARAMS, outcome });
-            expect(event.outcome).toBe(outcome);
-        }
-    });
-});
-describe("AuditEventSchema", () => {
-    it("validates a complete audit event", () => {
-        const event = {
-            id: "550e8400-e29b-41d4-a716-446655440000",
-            timestamp: "2026-01-01T00:00:00.000Z",
-            tenantId: "tenant-1",
-            agentId: "agent-1",
-            userId: "user-1",
-            actionType: "file.read",
-            classification: "read",
-            outcome: "success",
-            metadata: {},
-        };
-        const result = AuditEventSchema.safeParse(event);
-        expect(result.success).toBe(true);
-    });
-    it("rejects invalid UUID", () => {
-        const result = AuditEventSchema.safeParse({
-            id: "not-a-uuid",
-            timestamp: "2026-01-01T00:00:00.000Z",
-            tenantId: "t",
-            agentId: "a",
-            userId: "u",
-            actionType: "file.read",
-            classification: "read",
-            outcome: "success",
-            metadata: {},
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects empty tenantId", () => {
-        const result = AuditEventSchema.safeParse({
-            id: "550e8400-e29b-41d4-a716-446655440000",
-            timestamp: "2026-01-01T00:00:00.000Z",
-            tenantId: "",
-            agentId: "a",
-            userId: "u",
-            actionType: "file.read",
-            classification: "read",
-            outcome: "success",
-            metadata: {},
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects unknown fields (strict mode)", () => {
-        const result = AuditEventSchema.safeParse({
-            id: "550e8400-e29b-41d4-a716-446655440000",
-            timestamp: "2026-01-01T00:00:00.000Z",
-            tenantId: "t",
-            agentId: "a",
-            userId: "u",
-            actionType: "file.read",
-            classification: "read",
-            outcome: "success",
-            metadata: {},
-            extraField: "should-fail",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects negative duration", () => {
-        const result = AuditEventSchema.safeParse({
-            id: "550e8400-e29b-41d4-a716-446655440000",
-            timestamp: "2026-01-01T00:00:00.000Z",
-            tenantId: "t",
-            agentId: "a",
-            userId: "u",
-            actionType: "file.read",
-            classification: "read",
-            outcome: "success",
-            metadata: {},
-            duration: -1,
-        });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid classification", () => {
-        const result = AuditEventSchema.safeParse({
-            id: "550e8400-e29b-41d4-a716-446655440000",
-            timestamp: "2026-01-01T00:00:00.000Z",
-            tenantId: "t",
-            agentId: "a",
-            userId: "u",
-            actionType: "file.read",
-            classification: "unknown",
-            outcome: "success",
-            metadata: {},
-        });
-        expect(result.success).toBe(false);
-    });
-});

package/node_modules/@comis/core/dist/security/canary-token.test.d.ts

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

package/node_modules/@comis/core/dist/security/canary-token.test.js

@@ -1,45 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generateCanaryToken, detectCanaryLeakage } from "./canary-token.js";
-describe("generateCanaryToken", () => {
-    it("produces deterministic output for same session + secret", () => {
-        const token1 = generateCanaryToken("default:alice:ch-1", "test-secret");
-        const token2 = generateCanaryToken("default:alice:ch-1", "test-secret");
-        expect(token1).toBe(token2);
-    });
-    it("produces different tokens for different sessions", () => {
-        const token1 = generateCanaryToken("default:alice:ch-1", "test-secret");
-        const token2 = generateCanaryToken("default:bob:ch-2", "test-secret");
-        expect(token1).not.toBe(token2);
-    });
-    it("produces different tokens for different secrets", () => {
-        const token1 = generateCanaryToken("default:alice:ch-1", "secret-a");
-        const token2 = generateCanaryToken("default:alice:ch-1", "secret-b");
-        expect(token1).not.toBe(token2);
-    });
-    it('returns a token matching format "CTKN_" followed by 16 hex chars', () => {
-        const token = generateCanaryToken("default:alice:ch-1", "test-secret");
-        expect(token).toMatch(/^CTKN_[a-f0-9]{16}$/);
-    });
-});
-describe("detectCanaryLeakage", () => {
-    it("returns true when response contains the canary token", () => {
-        const canary = generateCanaryToken("default:alice:ch-1", "test-secret");
-        const response = `Here is some text with ${canary} embedded in it.`;
-        expect(detectCanaryLeakage(response, canary)).toBe(true);
-    });
-    it("returns false when response does not contain the canary token", () => {
-        const canary = generateCanaryToken("default:alice:ch-1", "test-secret");
-        const response = "This response has no canary token in it.";
-        expect(detectCanaryLeakage(response, canary)).toBe(false);
-    });
-    it("returns true when canary is at the start of the response", () => {
-        const canary = generateCanaryToken("default:alice:ch-1", "test-secret");
-        const response = `${canary} starts this response.`;
-        expect(detectCanaryLeakage(response, canary)).toBe(true);
-    });
-    it("returns true when canary is at the end of the response", () => {
-        const canary = generateCanaryToken("default:alice:ch-1", "test-secret");
-        const response = `This response ends with ${canary}`;
-        expect(detectCanaryLeakage(response, canary)).toBe(true);
-    });
-});

package/node_modules/@comis/core/dist/security/config-redaction.test.d.ts

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