comisai 1.0.11 → 1.0.13

package/node_modules/@comis/memory/dist/credential-mapping-schema.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Tests for credential mapping schema DDL.
- *
- * Uses in-memory SQLite databases with the secrets table as a prerequisite
- * (credential_mappings has a foreign key to secrets(name)).
- */
-export {};

package/node_modules/@comis/memory/dist/credential-mapping-schema.test.js

@@ -1,73 +0,0 @@
-/**
- * Tests for credential mapping schema DDL.
- *
- * Uses in-memory SQLite databases with the secrets table as a prerequisite
- * (credential_mappings has a foreign key to secrets(name)).
- */
-import { describe, it, expect, beforeEach } from "vitest";
-import Database from "better-sqlite3";
-import { initSecretSchema } from "./secret-store-schema.js";
-import { initCredentialMappingSchema } from "./credential-mapping-schema.js";
-describe("initCredentialMappingSchema", () => {
-    let db;
-    beforeEach(() => {
-        db = new Database(":memory:");
-        db.pragma("foreign_keys = ON");
-        // Prerequisite: secrets table must exist for the foreign key
-        initSecretSchema(db);
-    });
-    it("creates credential_mappings table with expected columns", () => {
-        initCredentialMappingSchema(db);
-        const columns = db
-            .prepare("PRAGMA table_info(credential_mappings)")
-            .all();
-        const columnNames = columns.map((c) => c.name);
-        expect(columnNames).toContain("id");
-        expect(columnNames).toContain("secret_name");
-        expect(columnNames).toContain("injection_type");
-        expect(columnNames).toContain("injection_key");
-        expect(columnNames).toContain("url_pattern");
-        expect(columnNames).toContain("tool_name");
-        // Should have exactly 6 columns
-        expect(columns).toHaveLength(6);
-        // Verify id is primary key
-        const pkColumn = columns.find((c) => c.pk === 1);
-        expect(pkColumn?.name).toBe("id");
-        // Verify NOT NULL constraints
-        const notNullColumns = columns.filter((c) => c.notnull === 1).map((c) => c.name);
-        expect(notNullColumns).toContain("secret_name");
-        expect(notNullColumns).toContain("injection_type");
-        expect(notNullColumns).toContain("url_pattern");
-    });
-    it("is idempotent (safe to call multiple times)", () => {
-        initCredentialMappingSchema(db);
-        initCredentialMappingSchema(db);
-        const columns = db
-            .prepare("PRAGMA table_info(credential_mappings)")
-            .all();
-        expect(columns).toHaveLength(6);
-    });
-    it("rejects invalid injection_type via CHECK constraint", () => {
-        initCredentialMappingSchema(db);
-        // Insert a valid secret first (foreign key prerequisite)
-        db.prepare("INSERT INTO secrets (name, ciphertext, iv, auth_tag, salt, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run("test-secret", Buffer.from("c"), Buffer.from("i"), Buffer.from("a"), Buffer.from("s"), Date.now(), Date.now());
-        expect(() => {
-            db.prepare("INSERT INTO credential_mappings (id, secret_name, injection_type, url_pattern) VALUES (?, ?, ?, ?)").run("map-1", "test-secret", "invalid", "https://api.example.com/*");
-        }).toThrow(/CHECK/);
-    });
-    it("rejects foreign key violation (non-existent secret)", () => {
-        initCredentialMappingSchema(db);
-        expect(() => {
-            db.prepare("INSERT INTO credential_mappings (id, secret_name, injection_type, url_pattern) VALUES (?, ?, ?, ?)").run("map-1", "nonexistent-secret", "bearer_header", "https://api.example.com/*");
-        }).toThrow(/FOREIGN KEY/);
-    });
-    it("creates indexes on secret_name and tool_name", () => {
-        initCredentialMappingSchema(db);
-        const indexes = db
-            .prepare("PRAGMA index_list(credential_mappings)")
-            .all();
-        const indexNames = indexes.map((i) => i.name);
-        expect(indexNames).toContain("idx_cred_map_secret");
-        expect(indexNames).toContain("idx_cred_map_tool");
-    });
-});

package/node_modules/@comis/memory/dist/credential-mapping-store.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Tests for CredentialMappingStore — CredentialMappingPort implementation
- * with SQLite CRUD operations.
- *
- * Uses in-memory SQLite databases with foreign_keys enabled.
- * Each test gets a fresh database with the secrets table and a dummy secret.
- */
-export {};

package/node_modules/@comis/memory/dist/credential-mapping-store.test.js

@@ -1,340 +0,0 @@
-/**
- * Tests for CredentialMappingStore — CredentialMappingPort implementation
- * with SQLite CRUD operations.
- *
- * Uses in-memory SQLite databases with foreign_keys enabled.
- * Each test gets a fresh database with the secrets table and a dummy secret.
- */
-import { describe, it, expect, beforeEach } from "vitest";
-import Database from "better-sqlite3";
-import { initSecretSchema } from "./secret-store-schema.js";
-import { createCredentialMappingStore } from "./credential-mapping-store.js";
-/** Unwrap a Result or fail the test. */
-function unwrap(result) {
-    if (!result.ok) {
-        throw new Error(`Expected ok result, got error: ${result.error.message}`);
-    }
-    return result.value;
-}
-/** Insert a dummy secret into the secrets table (needed for foreign key). */
-function insertDummySecret(db, name) {
-    db.prepare("INSERT INTO secrets (name, ciphertext, iv, auth_tag, salt, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(name, Buffer.from("c"), Buffer.from("i"), Buffer.from("a"), Buffer.from("s"), Date.now(), Date.now());
-}
-describe("createCredentialMappingStore", () => {
-    let db;
-    beforeEach(() => {
-        db = new Database(":memory:");
-        db.pragma("foreign_keys = ON");
-        initSecretSchema(db);
-        insertDummySecret(db, "OPENAI_API_KEY");
-        insertDummySecret(db, "BRAVE_API_KEY");
-    });
-    describe("set + get roundtrip", () => {
-        it("stores and retrieves a bearer_header mapping", () => {
-            const store = createCredentialMappingStore(db);
-            const mapping = {
-                id: "map-001",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api.openai.com/*",
-            };
-            const setResult = store.set(mapping);
-            expect(setResult.ok).toBe(true);
-            const retrieved = unwrap(store.get("map-001"));
-            expect(retrieved).toBeDefined();
-            expect(retrieved.id).toBe("map-001");
-            expect(retrieved.secretName).toBe("OPENAI_API_KEY");
-            expect(retrieved.injectionType).toBe("bearer_header");
-            expect(retrieved.urlPattern).toBe("https://api.openai.com/*");
-            expect(retrieved.injectionKey).toBeUndefined();
-            expect(retrieved.toolName).toBeUndefined();
-        });
-        it("stores and retrieves a custom_header mapping with injectionKey", () => {
-            const store = createCredentialMappingStore(db);
-            const mapping = {
-                id: "map-002",
-                secretName: "BRAVE_API_KEY",
-                injectionType: "custom_header",
-                injectionKey: "X-Subscription-Token",
-                urlPattern: "https://api.search.brave.com/*",
-                toolName: "brave_search",
-            };
-            unwrap(store.set(mapping));
-            const retrieved = unwrap(store.get("map-002"));
-            expect(retrieved).toBeDefined();
-            expect(retrieved.injectionType).toBe("custom_header");
-            expect(retrieved.injectionKey).toBe("X-Subscription-Token");
-            expect(retrieved.toolName).toBe("brave_search");
-        });
-        it("stores and retrieves a query_param mapping with injectionKey", () => {
-            const store = createCredentialMappingStore(db);
-            const mapping = {
-                id: "map-003",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "query_param",
-                injectionKey: "api_key",
-                urlPattern: "https://api.example.com/*",
-            };
-            unwrap(store.set(mapping));
-            const retrieved = unwrap(store.get("map-003"));
-            expect(retrieved).toBeDefined();
-            expect(retrieved.injectionType).toBe("query_param");
-            expect(retrieved.injectionKey).toBe("api_key");
-        });
-        it("stores and retrieves a basic_auth mapping", () => {
-            const store = createCredentialMappingStore(db);
-            const mapping = {
-                id: "map-004",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "basic_auth",
-                urlPattern: "https://internal.example.com/*",
-            };
-            unwrap(store.set(mapping));
-            const retrieved = unwrap(store.get("map-004"));
-            expect(retrieved).toBeDefined();
-            expect(retrieved.injectionType).toBe("basic_auth");
-            expect(retrieved.injectionKey).toBeUndefined();
-        });
-    });
-    describe("get", () => {
-        it("returns undefined for non-existent mapping", () => {
-            const store = createCredentialMappingStore(db);
-            const retrieved = unwrap(store.get("nonexistent"));
-            expect(retrieved).toBeUndefined();
-        });
-    });
-    describe("listAll", () => {
-        it("returns all inserted mappings", () => {
-            const store = createCredentialMappingStore(db);
-            unwrap(store.set({
-                id: "map-a",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api.openai.com/*",
-            }));
-            unwrap(store.set({
-                id: "map-b",
-                secretName: "BRAVE_API_KEY",
-                injectionType: "custom_header",
-                injectionKey: "X-Subscription-Token",
-                urlPattern: "https://api.search.brave.com/*",
-                toolName: "brave_search",
-            }));
-            const all = unwrap(store.listAll());
-            expect(all).toHaveLength(2);
-            const ids = all.map((m) => m.id).sort();
-            expect(ids).toEqual(["map-a", "map-b"]);
-        });
-        it("returns empty array when no mappings exist", () => {
-            const store = createCredentialMappingStore(db);
-            const all = unwrap(store.listAll());
-            expect(all).toEqual([]);
-        });
-    });
-    describe("listBySecret", () => {
-        it("filters by secret name", () => {
-            const store = createCredentialMappingStore(db);
-            unwrap(store.set({
-                id: "map-a",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api.openai.com/*",
-            }));
-            unwrap(store.set({
-                id: "map-b",
-                secretName: "BRAVE_API_KEY",
-                injectionType: "custom_header",
-                injectionKey: "X-Subscription-Token",
-                urlPattern: "https://api.search.brave.com/*",
-            }));
-            unwrap(store.set({
-                id: "map-c",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "query_param",
-                injectionKey: "key",
-                urlPattern: "https://other.openai.com/*",
-            }));
-            const openaiMappings = unwrap(store.listBySecret("OPENAI_API_KEY"));
-            expect(openaiMappings).toHaveLength(2);
-            expect(openaiMappings.every((m) => m.secretName === "OPENAI_API_KEY")).toBe(true);
-            const braveMappings = unwrap(store.listBySecret("BRAVE_API_KEY"));
-            expect(braveMappings).toHaveLength(1);
-            expect(braveMappings[0].id).toBe("map-b");
-        });
-        it("returns empty array when no mappings match", () => {
-            const store = createCredentialMappingStore(db);
-            const result = unwrap(store.listBySecret("NONEXISTENT_KEY"));
-            expect(result).toEqual([]);
-        });
-    });
-    describe("listByTool", () => {
-        it("filters by tool name (excludes null tool_name)", () => {
-            const store = createCredentialMappingStore(db);
-            unwrap(store.set({
-                id: "map-a",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api.openai.com/*",
-                // no toolName -- should NOT appear in listByTool results
-            }));
-            unwrap(store.set({
-                id: "map-b",
-                secretName: "BRAVE_API_KEY",
-                injectionType: "custom_header",
-                injectionKey: "X-Subscription-Token",
-                urlPattern: "https://api.search.brave.com/*",
-                toolName: "brave_search",
-            }));
-            unwrap(store.set({
-                id: "map-c",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api.openai.com/v1/*",
-                toolName: "brave_search",
-            }));
-            const braveMappings = unwrap(store.listByTool("brave_search"));
-            expect(braveMappings).toHaveLength(2);
-            expect(braveMappings.every((m) => m.toolName === "brave_search")).toBe(true);
-            // Mapping without toolName should not appear
-            const ids = braveMappings.map((m) => m.id);
-            expect(ids).not.toContain("map-a");
-        });
-        it("returns empty array when no mappings match the tool", () => {
-            const store = createCredentialMappingStore(db);
-            const result = unwrap(store.listByTool("nonexistent_tool"));
-            expect(result).toEqual([]);
-        });
-    });
-    describe("delete", () => {
-        it("returns true when mapping exists and is deleted", () => {
-            const store = createCredentialMappingStore(db);
-            unwrap(store.set({
-                id: "map-to-delete",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api.openai.com/*",
-            }));
-            const deleted = unwrap(store.delete("map-to-delete"));
-            expect(deleted).toBe(true);
-            // Confirm deleted
-            const retrieved = unwrap(store.get("map-to-delete"));
-            expect(retrieved).toBeUndefined();
-        });
-        it("returns false when mapping does not exist", () => {
-            const store = createCredentialMappingStore(db);
-            const deleted = unwrap(store.delete("nonexistent"));
-            expect(deleted).toBe(false);
-        });
-    });
-    // ── DATA-08: URL pattern regex validation ────────────────────────
-    describe("urlPattern regex validation", () => {
-        it("accepts valid regex pattern", () => {
-            const store = createCredentialMappingStore(db);
-            const result = store.set({
-                id: "map-regex-valid",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api\\.example\\.com/.*",
-            });
-            expect(result.ok).toBe(true);
-        });
-        it("accepts broad wildcard pattern", () => {
-            const store = createCredentialMappingStore(db);
-            const result = store.set({
-                id: "map-regex-broad",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: ".*",
-            });
-            expect(result.ok).toBe(true);
-        });
-        it("returns err for unclosed parenthesis", () => {
-            const store = createCredentialMappingStore(db);
-            const result = store.set({
-                id: "map-regex-bad-paren",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "(unclosed",
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.message).toContain("Invalid urlPattern");
-                expect(result.error.message).toContain("(unclosed");
-            }
-        });
-        it("returns err for unclosed bracket", () => {
-            const store = createCredentialMappingStore(db);
-            const result = store.set({
-                id: "map-regex-bad-bracket",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "[invalid",
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.message).toContain("Invalid urlPattern");
-            }
-        });
-    });
-    describe("upsert behavior", () => {
-        it("updates existing mapping when same id is set twice", () => {
-            const store = createCredentialMappingStore(db);
-            unwrap(store.set({
-                id: "map-upsert",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api.openai.com/v1/*",
-            }));
-            // Update with different values
-            unwrap(store.set({
-                id: "map-upsert",
-                secretName: "BRAVE_API_KEY",
-                injectionType: "custom_header",
-                injectionKey: "X-Api-Key",
-                urlPattern: "https://api.search.brave.com/*",
-                toolName: "brave_search",
-            }));
-            const retrieved = unwrap(store.get("map-upsert"));
-            expect(retrieved).toBeDefined();
-            expect(retrieved.secretName).toBe("BRAVE_API_KEY");
-            expect(retrieved.injectionType).toBe("custom_header");
-            expect(retrieved.injectionKey).toBe("X-Api-Key");
-            expect(retrieved.urlPattern).toBe("https://api.search.brave.com/*");
-            expect(retrieved.toolName).toBe("brave_search");
-            // Should still be only one mapping
-            const all = unwrap(store.listAll());
-            expect(all).toHaveLength(1);
-        });
-    });
-    describe("ON DELETE CASCADE", () => {
-        it("deletes credential mappings when referenced secret is deleted", () => {
-            const store = createCredentialMappingStore(db);
-            unwrap(store.set({
-                id: "map-cascade-1",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "bearer_header",
-                urlPattern: "https://api.openai.com/*",
-            }));
-            unwrap(store.set({
-                id: "map-cascade-2",
-                secretName: "OPENAI_API_KEY",
-                injectionType: "query_param",
-                injectionKey: "key",
-                urlPattern: "https://other.openai.com/*",
-            }));
-            // Verify mappings exist
-            const before = unwrap(store.listBySecret("OPENAI_API_KEY"));
-            expect(before).toHaveLength(2);
-            // Delete the referenced secret from the secrets table
-            db.prepare("DELETE FROM secrets WHERE name = ?").run("OPENAI_API_KEY");
-            // Mappings should be cascade-deleted
-            const after = unwrap(store.listBySecret("OPENAI_API_KEY"));
-            expect(after).toHaveLength(0);
-            // Verify via get too
-            const mapping1 = unwrap(store.get("map-cascade-1"));
-            expect(mapping1).toBeUndefined();
-            const mapping2 = unwrap(store.get("map-cascade-2"));
-            expect(mapping2).toBeUndefined();
-        });
-    });
-});

package/node_modules/@comis/memory/dist/delivery-mirror-adapter.test.d.ts

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

package/node_modules/@comis/memory/dist/delivery-mirror-adapter.test.js

@@ -1,165 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import Database from "better-sqlite3";
-import { createSqliteDeliveryMirror } from "./delivery-mirror-adapter.js";
-import { createNoOpDeliveryMirror } from "@comis/core";
-import { initSchema } from "./schema.js";
-describe("createSqliteDeliveryMirror", () => {
-    let db;
-    let mirror;
-    beforeEach(() => {
-        db = new Database(":memory:");
-        initSchema(db, 128);
-        mirror = createSqliteDeliveryMirror(db);
-    });
-    afterEach(() => {
-        db.close();
-    });
-    function makeInput(overrides = {}) {
-        return {
-            sessionKey: "telegram:dm:user123",
-            text: "Hello from agent",
-            mediaUrls: [],
-            channelType: "telegram",
-            channelId: "chat-001",
-            origin: "agent",
-            idempotencyKey: `key-${Date.now()}-${Math.random()}`,
-            ...overrides,
-        };
-    }
-    it("record() inserts a mirror entry and returns an id", async () => {
-        const result = await mirror.record(makeInput());
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(typeof result.value).toBe("string");
-        expect(result.value.length).toBeGreaterThan(0);
-        const pending = await mirror.pending("telegram:dm:user123");
-        expect(pending.ok).toBe(true);
-        if (!pending.ok)
-            return;
-        expect(pending.value).toHaveLength(1);
-        expect(pending.value[0].text).toBe("Hello from agent");
-    });
-    it("record() with duplicate idempotency key is silently ignored", async () => {
-        const input = makeInput({ idempotencyKey: "dup-key-001" });
-        const r1 = await mirror.record(input);
-        expect(r1.ok).toBe(true);
-        const r2 = await mirror.record({ ...input, text: "Different text" });
-        expect(r2.ok).toBe(true);
-        const pending = await mirror.pending("telegram:dm:user123");
-        expect(pending.ok).toBe(true);
-        if (!pending.ok)
-            return;
-        expect(pending.value).toHaveLength(1);
-        expect(pending.value[0].text).toBe("Hello from agent");
-    });
-    it("pending() returns entries ordered by created_at ASC", async () => {
-        // Insert directly with controlled timestamps to ensure ordering
-        db.exec(`
-      INSERT INTO delivery_mirror (id, session_key, text, media_urls, channel_type, channel_id, origin, idempotency_key, status, created_at)
-      VALUES ('id-3', 'sess-a', 'Third', '[]', 'telegram', 'ch1', 'agent', 'k3', 'pending', 3000);
-    `);
-        db.exec(`
-      INSERT INTO delivery_mirror (id, session_key, text, media_urls, channel_type, channel_id, origin, idempotency_key, status, created_at)
-      VALUES ('id-1', 'sess-a', 'First', '[]', 'telegram', 'ch1', 'agent', 'k1', 'pending', 1000);
-    `);
-        db.exec(`
-      INSERT INTO delivery_mirror (id, session_key, text, media_urls, channel_type, channel_id, origin, idempotency_key, status, created_at)
-      VALUES ('id-2', 'sess-a', 'Second', '[]', 'telegram', 'ch1', 'agent', 'k2', 'pending', 2000);
-    `);
-        const pending = await mirror.pending("sess-a");
-        expect(pending.ok).toBe(true);
-        if (!pending.ok)
-            return;
-        expect(pending.value).toHaveLength(3);
-        expect(pending.value[0].text).toBe("First");
-        expect(pending.value[1].text).toBe("Second");
-        expect(pending.value[2].text).toBe("Third");
-    });
-    it("pending() returns only entries for the given sessionKey", async () => {
-        await mirror.record(makeInput({ sessionKey: "sess-a", idempotencyKey: "ka" }));
-        await mirror.record(makeInput({ sessionKey: "sess-b", idempotencyKey: "kb" }));
-        const pendingA = await mirror.pending("sess-a");
-        expect(pendingA.ok).toBe(true);
-        if (!pendingA.ok)
-            return;
-        expect(pendingA.value).toHaveLength(1);
-        const pendingB = await mirror.pending("sess-b");
-        expect(pendingB.ok).toBe(true);
-        if (!pendingB.ok)
-            return;
-        expect(pendingB.value).toHaveLength(1);
-    });
-    it("acknowledge() marks entries as acknowledged", async () => {
-        const r1 = await mirror.record(makeInput({ idempotencyKey: "ack-1" }));
-        const r2 = await mirror.record(makeInput({ idempotencyKey: "ack-2" }));
-        expect(r1.ok).toBe(true);
-        expect(r2.ok).toBe(true);
-        if (!r1.ok || !r2.ok)
-            return;
-        const ackResult = await mirror.acknowledge([r1.value, r2.value]);
-        expect(ackResult.ok).toBe(true);
-        const pending = await mirror.pending("telegram:dm:user123");
-        expect(pending.ok).toBe(true);
-        if (!pending.ok)
-            return;
-        expect(pending.value).toHaveLength(0);
-    });
-    it("pruneOld() removes entries older than maxAgeMs", async () => {
-        const now = Date.now();
-        // Insert old entry via direct SQL
-        db.exec(`
-      INSERT INTO delivery_mirror (id, session_key, text, media_urls, channel_type, channel_id, origin, idempotency_key, status, created_at)
-      VALUES ('old-1', 'sess-a', 'Old', '[]', 'telegram', 'ch1', 'agent', 'prune-old', 'pending', ${now - 100_000});
-    `);
-        // Insert recent entry via adapter
-        await mirror.record(makeInput({ sessionKey: "sess-a", idempotencyKey: "prune-new" }));
-        const pruned = await mirror.pruneOld(50_000);
-        expect(pruned.ok).toBe(true);
-        if (!pruned.ok)
-            return;
-        expect(pruned.value).toBe(1);
-        const pending = await mirror.pending("sess-a");
-        expect(pending.ok).toBe(true);
-        if (!pending.ok)
-            return;
-        expect(pending.value).toHaveLength(1);
-        expect(pending.value[0].idempotencyKey).toBe("prune-new");
-    });
-    it("record() stores mediaUrls as JSON", async () => {
-        const urls = ["https://example.com/a.png", "https://example.com/b.jpg"];
-        await mirror.record(makeInput({ mediaUrls: urls, idempotencyKey: "media-1" }));
-        const pending = await mirror.pending("telegram:dm:user123");
-        expect(pending.ok).toBe(true);
-        if (!pending.ok)
-            return;
-        expect(pending.value[0].mediaUrls).toEqual(urls);
-    });
-});
-describe("createNoOpDeliveryMirror", () => {
-    it("returns success for all operations", async () => {
-        const noop = createNoOpDeliveryMirror();
-        const recordResult = await noop.record({
-            sessionKey: "s",
-            text: "t",
-            mediaUrls: [],
-            channelType: "echo",
-            channelId: "c",
-            origin: "agent",
-            idempotencyKey: "k",
-        });
-        expect(recordResult.ok).toBe(true);
-        if (recordResult.ok)
-            expect(typeof recordResult.value).toBe("string");
-        const pendingResult = await noop.pending("s");
-        expect(pendingResult.ok).toBe(true);
-        if (pendingResult.ok)
-            expect(pendingResult.value).toEqual([]);
-        const ackResult = await noop.acknowledge(["id1"]);
-        expect(ackResult.ok).toBe(true);
-        const pruneResult = await noop.pruneOld(1000);
-        expect(pruneResult.ok).toBe(true);
-        if (pruneResult.ok)
-            expect(pruneResult.value).toBe(0);
-    });
-});

package/node_modules/@comis/memory/dist/delivery-queue-adapter.test.d.ts

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