@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/org/handoff.test.mjs

@@ -1,269 +0,0 @@
-/**
- * handoff.test.mjs — tests for A2A handoff envelopes + dispatch + ingest.
- * Run: node --test lib/org/handoff.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  HANDOFF_FENCE, buildHandoffEnvelope, parseHandoffEnvelope, resolveTarget,
-  recordHandoff, sendHandoff, ingestHandoff,
-} from "./handoff.mjs";
-
-function tmp() { return mkdtempSync(join(tmpdir(), "org-handoff-")); }
-const NOW = Date.parse("2026-06-03T12:00:00Z");
-
-test("buildHandoffEnvelope: human line + fenced JSON envelope", () => {
-  const { text, envelope, id } = buildHandoffEnvelope({
-    from: "alex-ai", to: "Bob", intent: "Review the Q3 deck", payload: { context: "due Friday" }, nowMs: NOW,
-  });
-  assert.match(text, /🤝 Handoff for Bob from alex-ai/);
-  assert.match(text, new RegExp("```" + HANDOFF_FENCE));
-  assert.equal(envelope.intent, "Review the Q3 deck");
-  assert.equal(envelope.payload.context, "due Friday");
-  assert.ok(id.startsWith("ho-"));
-});
-
-test("parseHandoffEnvelope: round-trips build output; null for non-handoff", () => {
-  const { text, envelope } = buildHandoffEnvelope({ from: "a", to: "b", intent: "do x", nowMs: NOW });
-  const parsed = parseHandoffEnvelope(text);
-  assert.equal(parsed.id, envelope.id);
-  assert.equal(parsed.intent, "do x");
-  assert.equal(parseHandoffEnvelope("just a normal slack message"), null);
-  assert.equal(parseHandoffEnvelope("```" + HANDOFF_FENCE + "\nnot json\n```"), null);
-});
-
-test("resolveTarget: by id, name, slackId, email; null otherwise", () => {
-  const dir = [{ id: "bob-ai", name: "Bob", fullName: "Bob Lee", slackId: "U2", email: "bob@x.com" }];
-  assert.equal(resolveTarget(dir, "bob-ai").id, "bob-ai");
-  assert.equal(resolveTarget(dir, "Bob").id, "bob-ai");
-  assert.equal(resolveTarget(dir, "@U2").id, "bob-ai");
-  assert.equal(resolveTarget(dir, "bob@x.com").id, "bob-ai");
-  assert.equal(resolveTarget(dir, "carol"), null);
-});
-
-test("recordHandoff: appends to state/org/handoffs.jsonl", () => {
-  const root = tmp();
-  try {
-    recordHandoff(root, { id: "ho-1", intent: "x" }, "outbound");
-    const p = join(root, "state", "org", "handoffs.jsonl");
-    assert.ok(existsSync(p));
-    assert.match(readFileSync(p, "utf8"), /"direction":"outbound"/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("sendHandoff: resolves target, records, dispatches via injected transport", async () => {
-  const root = tmp();
-  try {
-    const calls = [];
-    const transportFn = async ({ target, text }) => { calls.push({ target, text }); return { ok: true, channel: `slack:${target.slackId}` }; };
-    const res = await sendHandoff({
-      agentRoot: root, from: "alex-ai", to: "bob", intent: "ship it",
-      directory: [{ id: "bob-ai", name: "Bob", slackId: "U2" }], transportFn, nowMs: NOW,
-    });
-    assert.equal(res.sent, true);
-    assert.equal(res.target.id, "bob-ai");
-    assert.equal(calls.length, 1);
-    assert.match(readFileSync(join(root, "state", "org", "handoffs.jsonl"), "utf8"), /"direction":"outbound"/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("sendHandoff: no resolvable target → not sent (but still recorded)", async () => {
-  const root = tmp();
-  try {
-    const res = await sendHandoff({ agentRoot: root, from: "a", to: "ghost", intent: "x", directory: [], nowMs: NOW });
-    assert.equal(res.sent, false);
-    assert.equal(res.target, null);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("ingestHandoff: envelope → provenance-tagged task; default enqueue is idempotent", async () => {
-  const root = tmp();
-  try {
-    const { text } = buildHandoffEnvelope({ from: "bob-ai", to: "alex", intent: "draft the memo", payload: { priority: "high", context: "board wants it" }, nowMs: NOW });
-    const task = await ingestHandoff({ agentRoot: root, text, nowMs: NOW });
-    assert.equal(task.source, "a2a-handoff");
-    assert.equal(task.from_agent, "bob-ai");
-    assert.equal(task.title, "draft the memo");
-    assert.equal(task.priority, "high");
-    // idempotent: ingest the same envelope again → still one queue item
-    await ingestHandoff({ agentRoot: root, text, nowMs: NOW });
-    const m = await import("js-yaml");
-    const doc = (m.default || m).load(readFileSync(join(root, "state", "queues", "handoffs.yaml"), "utf8"));
-    assert.equal(doc.items.length, 1, "same handoff_id not enqueued twice");
-    assert.match(readFileSync(join(root, "state", "org", "handoffs.jsonl"), "utf8"), /"direction":"inbound"/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("ingestHandoff: plain text → null", async () => {
-  assert.equal(await ingestHandoff({ agentRoot: tmp(), text: "hello there" }), null);
-});
-
-// --- v2 signed envelope ----------------------------------------------------
-
-test("buildHandoffEnvelope: signer present → v2 with sig/keyId/deadline; verifies", async () => {
-  const { generateDeviceKey, signWith, verifySignature } = await import("./keys.mjs");
-  const { canonicalize } = await import("./protocol.mjs");
-  const kp = generateDeviceKey();
-  const { envelope } = buildHandoffEnvelope({
-    from: "alex-ai", to: "bob-ai", intent: "do x", itemId: "wi_1", deadline: "2026-06-12T00:00:00Z",
-    sign: (d) => signWith(kp.privateKeyPem, d), keyId: "alex#1", nowMs: NOW,
-  });
-  assert.equal(envelope.v, 2);
-  assert.equal(envelope.keyId, "alex#1");
-  assert.equal(envelope.deadline, "2026-06-12T00:00:00Z");
-  assert.ok(envelope.sig);
-  // re-derive the signing material exactly as build did (sig stripped) → verifies
-  const { sig, ...unsigned } = envelope;
-  assert.equal(verifySignature(kp.publicKeyPem, canonicalize(unsigned), sig), true);
-});
-
-test("buildHandoffEnvelope: no signer → stays v1 (file-transport compatible)", () => {
-  const { envelope } = buildHandoffEnvelope({ from: "a", to: "b", intent: "x", nowMs: NOW });
-  assert.equal(envelope.v, 1);
-  assert.ok(!("sig" in envelope));
-});
-
-// --- Cohort routing: sendHandoff through handoff.offer ----------------------
-
-const ON = { org: { cohort: { enabled: true, base: "https://org.cohortapp.com", token: "tok" } } };
-
-/** A fetch fake that records the /v1 calls and returns a canned res frame. */
-function fakeFetch(responder) {
-  const calls = [];
-  const impl = async (url, init) => {
-    calls.push({ url, init });
-    const r = responder ? responder(url, init) : null;
-    const body = r ? r.body : { ok: true, result: null };
-    const status = r && r.status ? r.status : 200;
-    return { ok: status >= 200 && status < 300, status, headers: { get: () => undefined }, json: async () => body };
-  };
-  impl.calls = calls;
-  return impl;
-}
-
-test("sendHandoff: org.cohort enabled → routes through POST /v1/handoff.offer", async () => {
-  const root = tmp();
-  try {
-    const f = fakeFetch((url) => {
-      assert.match(url, /\/v1\/handoff\.offer$/);
-      return { body: { ok: true, result: { handoffId: "x", state: "offered" } } };
-    });
-    const res = await sendHandoff({
-      agentRoot: root, cfg: ON, from: "alex-ai", to: "bob",
-      intent: "ship it", itemId: "wi_1", directory: [{ id: "bob-ai", name: "Bob", slackId: "U2" }],
-      fetchImpl: f, nowMs: NOW,
-    });
-    assert.equal(res.via, "cohort");
-    assert.equal(res.sent, true);
-    assert.equal(res.target.id, "bob-ai");
-    assert.equal(f.calls.length, 1);
-    const body = JSON.parse(f.calls[0].init.body);
-    // The wire contract handoff.offer requires {itemId, toAgent, intent}; the
-    // signed envelope is carried so the server can key the run on its id.
-    assert.equal(body.toAgent, "bob-ai");            // exact agent_id only
-    assert.equal(body.itemId, "wi_1");
-    assert.equal(body.intent, "ship it");
-    assert.equal(body.envelope.id, res.envelope.id);
-    assert.equal(f.calls[0].init.headers["x-idempotency-key"], `handoff.offer:${res.envelope.id}`);
-    // still recorded locally
-    assert.match(readFileSync(join(root, "state", "org", "handoffs.jsonl"), "utf8"), /"direction":"outbound"/);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("sendHandoff: enabled but governance not ready → sent:false, code surfaced", async () => {
-  const root = tmp();
-  try {
-    const f = fakeFetch(() => ({ status: 423, body: { ok: false, error: { code: "GOVERNANCE_NOT_READY", message: "no rights" } } }));
-    const res = await sendHandoff({
-      agentRoot: root, cfg: ON, from: "a", to: "bob", intent: "x", itemId: "wi_1",
-      directory: [{ id: "bob-ai", name: "Bob" }], fetchImpl: f, nowMs: NOW,
-    });
-    assert.equal(res.via, "cohort");
-    assert.equal(res.sent, false);
-    assert.equal(res.transport.reason, "GOVERNANCE_NOT_READY");
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("sendHandoff: org disabled → falls back to file transport (no /v1 call)", async () => {
-  const root = tmp();
-  try {
-    let fetchHit = false;
-    const f = () => { fetchHit = true; throw new Error("should not be called"); };
-    const calls = [];
-    const transportFn = async ({ target, text }) => { calls.push({ target, text }); return { ok: true }; };
-    const res = await sendHandoff({
-      agentRoot: root, cfg: { org: { cohort: { enabled: false } } },
-      from: "alex-ai", to: "bob", intent: "ship", directory: [{ id: "bob-ai", name: "Bob", slackId: "U2" }],
-      transportFn, fetchImpl: f, nowMs: NOW,
-    });
-    assert.equal(res.via, "file");
-    assert.equal(res.sent, true);
-    assert.equal(calls.length, 1);
-    assert.equal(fetchHit, false, "no /v1 call when org plane is disabled");
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("sendHandoff: no cfg → file transport (back-compat with existing callers)", async () => {
-  const root = tmp();
-  try {
-    const calls = [];
-    const res = await sendHandoff({
-      agentRoot: root, from: "alex-ai", to: "bob", intent: "ship",
-      directory: [{ id: "bob-ai", name: "Bob", slackId: "U2" }],
-      transportFn: async ({ target }) => { calls.push(target); return { ok: true }; }, nowMs: NOW,
-    });
-    assert.equal(res.via, "file");
-    assert.equal(res.sent, true);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-// --- Cohort routing: ingestHandoff through handoff.accept -------------------
-
-test("ingestHandoff: org enabled → accepts via POST /v1/handoff.accept, then enqueues", async () => {
-  const root = tmp();
-  try {
-    const { text } = buildHandoffEnvelope({ from: "bob-ai", to: "alex", intent: "draft memo", nowMs: NOW });
-    const f = fakeFetch((url) => {
-      assert.match(url, /\/v1\/handoff\.accept$/);
-      return { body: { ok: true, result: { state: "accepted" } } };
-    });
-    const task = await ingestHandoff({ agentRoot: root, cfg: ON, text, fetchImpl: f, nowMs: NOW });
-    assert.equal(task.accept_status, "accepted");
-    assert.equal(f.calls.length, 1);
-    const body = JSON.parse(f.calls[0].init.body);
-    assert.equal(body.handoffId, task.handoff_id);
-    // local enqueue still happens (idempotent)
-    const m = await import("js-yaml");
-    const doc = (m.default || m).load(readFileSync(join(root, "state", "queues", "handoffs.yaml"), "utf8"));
-    assert.equal(doc.items.length, 1);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("ingestHandoff: org disabled → no /v1 call, accept_status 'file'", async () => {
-  const root = tmp();
-  try {
-    const { text } = buildHandoffEnvelope({ from: "bob-ai", to: "alex", intent: "x", nowMs: NOW });
-    let hit = false;
-    const f = () => { hit = true; throw new Error("nope"); };
-    const task = await ingestHandoff({ agentRoot: root, cfg: { org: { cohort: { enabled: false } } }, text, fetchImpl: f, nowMs: NOW });
-    assert.equal(task.accept_status, "file");
-    assert.equal(hit, false);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("ingestHandoff: enabled but accept gated → fail-open, task still enqueued", async () => {
-  const root = tmp();
-  try {
-    const { text } = buildHandoffEnvelope({ from: "bob-ai", to: "alex", intent: "x", nowMs: NOW });
-    const f = fakeFetch(() => ({ status: 423, body: { ok: false, error: { code: "GOVERNANCE_NOT_READY", message: "x" } } }));
-    const task = await ingestHandoff({ agentRoot: root, cfg: ON, text, fetchImpl: f, nowMs: NOW });
-    assert.equal(task.accept_status, "GOVERNANCE_NOT_READY");
-    assert.equal(task.title, "x");  // local enqueue not blocked by the gated accept
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});