@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/scripts/daemon/session-lock.test.mjs

@@ -1,252 +0,0 @@
-#!/usr/bin/env node
-/**
- * test-session-lock.mjs — Tests for file-based session locks and sent-message registry
- */
-
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
-import { join } from "path";
-
-// Tests use a temporary directory to avoid polluting real state
-const TEST_DIR = join(import.meta.dirname, "../../.test-session-locks");
-const LOCKS_DIR = join(TEST_DIR, "locks");
-const REGISTRY_PATH = join(TEST_DIR, "sent-registry.jsonl");
-
-// We'll set these env vars so the module uses our test paths
-process.env.__TEST_SESSION_DIR = TEST_DIR;
-
-const {
-  sanitiseItemId,
-  acquireLock,
-  releaseLock,
-  updateLock,
-  readLock,
-  scanStaleLocks,
-  checkRecentlySent,
-  registerSent,
-} = await import("./session-lock.mjs");
-
-// ─── sanitiseItemId ─────────────────────────────────────────────
-
-describe("sanitiseItemId", () => {
-  it("replaces colons and dots with hyphens", () => {
-    assert.equal(
-      sanitiseItemId("slack:D099N1JGKRQ:1775331885.690669"),
-      "slack-D099N1JGKRQ-1775331885-690669"
-    );
-  });
-
-  it("handles simple alphanumeric IDs unchanged", () => {
-    assert.equal(sanitiseItemId("abc123"), "abc123");
-  });
-
-  it("replaces spaces and special chars", () => {
-    assert.equal(sanitiseItemId("foo bar/baz@qux"), "foo-bar-baz-qux");
-  });
-});
-
-// ─── acquireLock / releaseLock / readLock ────────────────────────
-
-describe("acquireLock / releaseLock / readLock", () => {
-  beforeEach(() => {
-    mkdirSync(LOCKS_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  it("acquires a lock on first call", () => {
-    const result = acquireLock("test-item-1", { sender: "Alice", channel: "C001" });
-    assert.equal(result.acquired, true);
-    assert.equal(existsSync(join(LOCKS_DIR, "test-item-1.lock")), true);
-  });
-
-  it("rejects second acquire for same item", () => {
-    acquireLock("test-item-2", { sender: "Alice", channel: "C001" });
-    const result = acquireLock("test-item-2", { sender: "Bob", channel: "C002" });
-    assert.equal(result.acquired, false);
-    assert.ok(result.existing);
-    assert.equal(result.existing.sender, "Alice");
-  });
-
-  it("allows acquire after release", () => {
-    acquireLock("test-item-3", { sender: "Alice", channel: "C001" });
-    releaseLock("test-item-3");
-    const result = acquireLock("test-item-3", { sender: "Bob", channel: "C002" });
-    assert.equal(result.acquired, true);
-  });
-
-  it("readLock returns lock data when locked", () => {
-    acquireLock("test-item-4", { sender: "Alice", channel: "C001" });
-    const data = readLock("test-item-4");
-    assert.equal(data.sender, "Alice");
-    assert.equal(data.channel, "C001");
-    assert.equal(data.holdingSent, false);
-    assert.equal(data.substantiveSent, false);
-  });
-
-  it("readLock returns null when no lock", () => {
-    const data = readLock("nonexistent-item");
-    assert.equal(data, null);
-  });
-
-  it("overwrites stale lock (older than STALE_LOCK_MS)", () => {
-    // Write a lock older than STALE_LOCK_MS (2h — raised from 15min so it
-    // exceeds the longest inbox/Opus session and survives daemon restarts;
-    // see session-lock.mjs). A 3h-old lock is unambiguously stale.
-    const lockPath = join(LOCKS_DIR, "test-item-5.lock");
-    mkdirSync(LOCKS_DIR, { recursive: true });
-    const staleLock = {
-      sessionId: "old-session",
-      itemId: "test-item-5",
-      sender: "Alice",
-      channel: "C001",
-      acquiredAt: new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString(),
-      holdingSent: false,
-      substantiveSent: false,
-    };
-    writeFileSync(lockPath, JSON.stringify(staleLock));
-
-    const result = acquireLock("test-item-5", { sender: "Bob", channel: "C002" });
-    assert.equal(result.acquired, true);
-    const data = readLock("test-item-5");
-    assert.equal(data.sender, "Bob");
-  });
-
-  it("does NOT overwrite a fresh lock younger than STALE_LOCK_MS", () => {
-    // 20 min old: well within the 2h freshness window, so a re-acquire must be
-    // denied (this is the behaviour the old ">15 min" test wrongly assumed
-    // would expire). Guards against any future shortening of STALE_LOCK_MS that
-    // would re-introduce the mid-session triple-dispatch incident.
-    const lockPath = join(LOCKS_DIR, "test-item-5b.lock");
-    mkdirSync(LOCKS_DIR, { recursive: true });
-    writeFileSync(lockPath, JSON.stringify({
-      sessionId: "live-session", itemId: "test-item-5b", sender: "Alice", channel: "C001",
-      acquiredAt: new Date(Date.now() - 20 * 60 * 1000).toISOString(),
-      holdingSent: false, substantiveSent: false,
-    }));
-    const result = acquireLock("test-item-5b", { sender: "Bob", channel: "C002" });
-    assert.equal(result.acquired, false, "a 20-min-old lock is still fresh under the 2h window");
-    assert.equal(readLock("test-item-5b").sender, "Alice", "the live lock is preserved");
-  });
-});
-
-// ─── updateLock ─────────────────────────────────────────────────
-
-describe("updateLock", () => {
-  beforeEach(() => {
-    mkdirSync(LOCKS_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  it("updates holdingSent flag on existing lock", () => {
-    acquireLock("test-item-6", { sender: "Alice", channel: "C001" });
-    updateLock("test-item-6", { holdingSent: true });
-    const data = readLock("test-item-6");
-    assert.equal(data.holdingSent, true);
-    assert.equal(data.substantiveSent, false);
-  });
-
-  it("no-ops when lock does not exist", () => {
-    // Should not throw
-    updateLock("nonexistent", { holdingSent: true });
-  });
-});
-
-// ─── scanStaleLocks ─────────────────────────────────────────────
-
-describe("scanStaleLocks", () => {
-  beforeEach(() => {
-    mkdirSync(LOCKS_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  it("clears stale locks and leaves fresh ones", () => {
-    // Fresh lock
-    acquireLock("fresh-item", { sender: "Alice", channel: "C001" });
-
-    // Stale lock — older than STALE_LOCK_MS (2h). 3h ago is unambiguously
-    // stale. (The old fixture used 20min, which the raised threshold no longer
-    // treats as stale.)
-    const stalePath = join(LOCKS_DIR, "stale-item.lock");
-    writeFileSync(stalePath, JSON.stringify({
-      sessionId: "old", itemId: "stale-item", sender: "Bob", channel: "C002",
-      acquiredAt: new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString(),
-      holdingSent: false, substantiveSent: false,
-    }));
-
-    const cleared = scanStaleLocks();
-    assert.equal(cleared, 1);
-    assert.equal(existsSync(join(LOCKS_DIR, "fresh-item.lock")), true);
-    assert.equal(existsSync(stalePath), false);
-  });
-});
-
-// ─── sent-message registry ──────────────────────────────────────
-
-describe("sent-message registry", () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-    // Ensure clean registry
-    try { unlinkSync(REGISTRY_PATH); } catch {}
-  });
-
-  afterEach(() => {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  it("allows first send to a channel", () => {
-    const result = checkRecentlySent("C001", "1234.5678", "holding");
-    assert.equal(result.allowed, true);
-  });
-
-  it("blocks duplicate send to same channel+thread+type within window", () => {
-    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
-    const result = checkRecentlySent("C001", "1234.5678", "holding");
-    assert.equal(result.allowed, false);
-    assert.ok(result.reason.includes("duplicate"));
-  });
-
-  it("blocks a different type to the same channel+thread (thread cooldown — Rule 2)", () => {
-    // Rule 2 deliberately blocks ANY type within the same channel+thread window
-    // (not just same-type). This prevents cascading replies when one thread is
-    // re-ingested across poll cycles as different message types. (The original
-    // expectation — "different type is allowed" — predated Rule 2 and was a
-    // stale assertion; the product intentionally cools down the whole thread.)
-    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
-    const result = checkRecentlySent("C001", "1234.5678", "substantive");
-    assert.equal(result.allowed, false);
-    assert.match(result.reason, /thread cooldown/);
-  });
-
-  it("allows a different type to the same NON-threaded channel (no thread cooldown)", () => {
-    // With threadTs=null there is no thread to cool down, so Rule 1 (same
-    // channel+thread+TYPE) is the only same-channel gate — a different type is
-    // allowed. (Uses a non-DM channel so the DM channel-level dedup, Rule 0b,
-    // doesn't apply.)
-    registerSent("C010", null, "holding", "s-1", "Got it");
-    const result = checkRecentlySent("C010", null, "substantive");
-    assert.equal(result.allowed, true);
-  });
-
-  it("allows same type to different channel", () => {
-    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
-    const result = checkRecentlySent("C002", "1234.5678", "holding");
-    assert.equal(result.allowed, true);
-  });
-
-  it("blocks rapid substantive sends to same channel even with different threads", () => {
-    registerSent("C001", "1111.0000", "substantive", "s-1", "Here is the answer");
-    const result = checkRecentlySent("C001", "2222.0000", "substantive");
-    assert.equal(result.allowed, false);
-    assert.ok(result.reason.includes("rapid"));
-  });
-});