@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/org/mesh-integration.test.mjs

@@ -1,127 +0,0 @@
-/**
- * mesh-integration.test.mjs — SP5 hot-refresh from the mesh beat + the
- * `toolset_changed` directive.
- *
- * Covers: beatOnce polls + refetches the granted integration tools and writes
- * state/org/toolset.json on a version change; a matching version writes nothing;
- * a `toolset_changed` directive forces an immediate refresh ahead of the poll;
- * the directive is a KNOWN directive. Hermetic: client is a stub, disk is a
- * mkdtemp root. Run: node --test lib/org/mesh-integration.test.mjs
- */
-
-"use strict";
-
-import { test, beforeEach, after } 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 { _internals } from "./mesh.mjs";
-import {
-  currentToolsetVersion,
-  getIntegrationTools,
-  integrationToolsetPath,
-  _resetForTest,
-} from "./integration-tools.mjs";
-
-const { beatOnce, handleDirective, KNOWN_DIRECTIVES } = _internals;
-
-const TOOLS = [
-  { slug: "open-meteo", name: "forecast", description: "d", inputSchema: {} },
-];
-
-const roots = [];
-function freshRoot() {
-  const r = mkdtempSync(join(tmpdir(), "mesh-int-"));
-  roots.push(r);
-  return r;
-}
-
-/** A mesh loop ctx with a stub client answering presence + the two SP1 reads. */
-function makeCtx(root, { version, tools = TOOLS, directives = [] }) {
-  const calls = [];
-  const client = {
-    presenceBeat: async () => ({ ok: true, result: { directives } }),
-    call: async (method, params) => {
-      calls.push({ method, params });
-      if (method === "integration.toolsetVersion") return { ok: true, result: { version } };
-      if (method === "integration.listAgentTools") return { ok: true, result: { version, tools } };
-      return { ok: false, error: { code: "NOT_FOUND", message: "?" } };
-    },
-  };
-  const ctx = {
-    agentRoot: root,
-    client,
-    base: "https://org.example",
-    token: "nlk",
-    orgId: "acme",
-    agentMemberId: "wm_self",
-    fetchImpl: undefined,
-    now: () => 1000,
-    beatFocus: null,
-    collectStatus: async () => undefined,
-    stopped: false,
-    requestStop() {},
-    stop() { this.stopped = true; },
-    _calls: calls,
-  };
-  return ctx;
-}
-
-beforeEach(() => _resetForTest());
-after(() => {
-  for (const r of roots) {
-    try { rmSync(r, { recursive: true, force: true }); } catch { /* best-effort */ }
-  }
-});
-
-test("toolset_changed is a recognised directive", () => {
-  assert.ok(KNOWN_DIRECTIVES.has("toolset_changed"));
-});
-
-test("beatOnce refreshes + writes state/org/toolset.json on a version change", async () => {
-  const root = freshRoot();
-  const ctx = makeCtx(root, { version: 4 });
-  const directives = await beatOnce(ctx);
-  assert.deepEqual(directives, []);
-  // Cache + disk both reflect v4 with the mapped tool.
-  assert.equal(currentToolsetVersion(), 4);
-  assert.equal(getIntegrationTools()[0].name, "plugin__open_meteo__forecast");
-  const p = integrationToolsetPath(root);
-  assert.ok(existsSync(p), "toolset.json written");
-  const doc = JSON.parse(readFileSync(p, "utf8"));
-  assert.equal(doc.version, 4);
-  assert.equal(doc.tools[0].name, "plugin__open_meteo__forecast");
-});
-
-test("beatOnce with an unchanged version does not refetch the manifest", async () => {
-  const root = freshRoot();
-  await beatOnce(makeCtx(root, { version: 4 })); // seed v4
-  const ctx = makeCtx(root, { version: 4 }); // same version, fresh spy
-  await beatOnce(ctx);
-  const methods = ctx._calls.map((c) => c.method);
-  assert.ok(methods.includes("integration.toolsetVersion"));
-  assert.ok(
-    !methods.includes("integration.listAgentTools"),
-    "no manifest refetch when the version is unchanged",
-  );
-});
-
-test("a toolset_changed directive forces an immediate refresh + disk write", async () => {
-  const root = freshRoot();
-  const ctx = makeCtx(root, { version: 7 });
-  await handleDirective("toolset_changed", ctx);
-  assert.equal(currentToolsetVersion(), 7);
-  const doc = JSON.parse(readFileSync(integrationToolsetPath(root), "utf8"));
-  assert.equal(doc.version, 7);
-});
-
-test("a refresh failure never throws out of the beat (fail-open)", async () => {
-  const root = freshRoot();
-  const ctx = makeCtx(root, { version: 1 });
-  ctx.client.call = async () => { throw new Error("network down"); };
-  const directives = await beatOnce(ctx); // must resolve, not reject
-  assert.deepEqual(directives, []);
-  assert.equal(existsSync(integrationToolsetPath(root)), false);
-});

package/lib/org/mesh.test.mjs

@@ -1,400 +0,0 @@
-/**
- * mesh.test.mjs — the agent's runtime membership of the org mesh (connectOrgMesh).
- *
- * Drives connectOrgMesh over an injected org client + injected interval + a tmp
- * agentRoot, asserting: registers on boot when enabled; no-op when disabled; a
- * "halt" beat directive trips the kill switch (.emergency-stop + requestStop);
- * "policy_stale" triggers a policy refetch; "resync" refetches the directory into
- * the local peers cache; an unreachable org never throws. No network.
- *
- * Run: node --test lib/org/mesh.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { connectOrgMesh, DEFAULT_BEAT_MS, _internals } from "./mesh.mjs";
-
-const BASE = "https://org.cohortapp.com";
-
-function tmpRepo() {
-  const root = mkdtempSync(join(tmpdir(), "org-mesh-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  writeFileSync(
-    join(root, "config", "agent.json"),
-    JSON.stringify({ firstName: "Alex", fullName: "Alex Chen", repoSlug: "alex-ai", title: "Chief of Staff" }),
-  );
-  return root;
-}
-
-function cfgEnabled() {
-  return { org: { cohort: { enabled: true, base: BASE, token: "tok" } } };
-}
-function cfgDisabled() {
-  return { org: { cohort: { enabled: false, base: BASE, token: "tok" } } };
-}
-
-/**
- * A fake org client. `beatFrames` is a queue of presence.beat frames to return
- * (one per beat); when drained it returns a benign empty-directives frame.
- * Records every register / presenceBeat / fetchDirectory call.
- */
-function fakeClient(opts = {}) {
-  const c = {
-    isEnabled: opts.isEnabled || ((cfg) => !!(cfg && cfg.org && cfg.org.cohort && cfg.org.cohort.enabled)),
-    configFromAgent: (cfg) => ({ base: BASE, token: "tok", orgId: "", enabled: true, trustedSignersPem: [] }),
-    registerCalls: [],
-    beatCalls: [],
-    directoryCalls: [],
-    _beatFrames: opts.beatFrames ? opts.beatFrames.slice() : [],
-    register(entry, o) {
-      c.registerCalls.push({ entry, o });
-      return Promise.resolve(opts.registerFrame || { ok: true, result: { status: 200 } });
-    },
-    presenceBeat(params, o) {
-      c.beatCalls.push({ params, o });
-      const frame = c._beatFrames.length ? c._beatFrames.shift() : { ok: true, result: { directives: [] } };
-      return Promise.resolve(frame);
-    },
-    fetchDirectory(o) {
-      c.directoryCalls.push({ o });
-      return Promise.resolve(opts.directory || []);
-    },
-  };
-  return c;
-}
-
-/** An injectable interval that never actually schedules; we beat manually. */
-function noopInterval() {
-  const fn = () => ({ unref() {} });
-  fn.cleared = [];
-  return { setInterval: fn, clearInterval: (t) => fn.cleared.push(t) };
-}
-
-// ---------------------------------------------------------------------------
-
-test("disabled org → no-op handle, never registers", async () => {
-  const root = tmpRepo();
-  const client = fakeClient();
-  const handle = await connectOrgMesh({ agentRoot: root, cfg: cfgDisabled(), client });
-  assert.equal(handle.isEnabled, false);
-  assert.equal(client.registerCalls.length, 0);
-  assert.doesNotThrow(() => handle.stop()); // inert stop is safe
-});
-
-test("enabled org → registers self on boot (idempotent key) + starts the beat", async () => {
-  const root = tmpRepo();
-  const client = fakeClient();
-  const iv = noopInterval();
-  let intervalArgs = null;
-  const setIntervalSpy = (cb, ms) => { intervalArgs = { cb, ms }; return { unref() {} }; };
-
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: setIntervalSpy, clearInterval: iv.clearInterval,
-  });
-
-  assert.equal(handle.isEnabled, true);
-  assert.equal(client.registerCalls.length, 1, "registered exactly once on boot");
-  const reg = client.registerCalls[0];
-  assert.equal(reg.entry.id, "alex-ai");
-  assert.equal(reg.o.idempotencyKey, "registry.register:alex-ai");
-  assert.equal(reg.o.base, BASE);
-  assert.ok(intervalArgs, "beat interval was scheduled");
-  assert.equal(intervalArgs.ms, DEFAULT_BEAT_MS);
-  handle.stop();
-});
-
-test('presence-beat "halt" directive trips the kill switch (.emergency-stop + requestStop)', async () => {
-  const root = tmpRepo();
-  const client = fakeClient({ beatFrames: [{ ok: true, result: { directives: ["halt"] } }] });
-  let stopRequested = 0;
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-    requestStop: () => { stopRequested += 1; },
-  });
-
-  // Drive one beat explicitly via the loop context.
-  const directives = await _internals.beatOnce(handle._ctx);
-  assert.deepEqual(directives, ["halt"]);
-  assert.ok(existsSync(join(root, ".emergency-stop")), ".emergency-stop flag was written");
-  const flag = readFileSync(join(root, ".emergency-stop"), "utf8");
-  assert.match(flag, /\d{4}-\d{2}-\d{2}T/, "flag carries a timestamp");
-  assert.equal(stopRequested, 1, "requestStop() was invoked");
-  assert.equal(handle._ctx.stopped, true, "the beat loop stopped itself on halt");
-});
-
-test('"halt" delivered via an error frame (deactivated token) also trips the kill switch', async () => {
-  const root = tmpRepo();
-  const client = fakeClient({ beatFrames: [{ ok: false, error: { code: "UNAUTHORIZED", directive: "halt" } }] });
-  let stopRequested = 0;
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-    requestStop: () => { stopRequested += 1; },
-  });
-  const directives = await _internals.beatOnce(handle._ctx);
-  assert.deepEqual(directives, ["halt"]);
-  assert.ok(existsSync(join(root, ".emergency-stop")));
-  assert.equal(stopRequested, 1);
-});
-
-test('"policy_stale" directive triggers a policy refetch (handlePolicyStale)', async () => {
-  const root = tmpRepo();
-  const client = fakeClient({ beatFrames: [{ ok: true, result: { directives: ["policy_stale"] } }] });
-
-  // Capture the policy.handlePolicyStale call by injecting a fetchImpl: the real
-  // policy module will call client.policyFetch through fetchImpl. We assert the
-  // refresh path runs end-to-end without throwing and that a fetch happened.
-  let policyFetchHits = 0;
-  const fetchImpl = async (url) => {
-    if (String(url).includes("/v1/policy")) policyFetchHits += 1;
-    // Return a bundle with no valid signature → policy quarantines it (fail-open).
-    return { ok: true, status: 200, headers: { get: () => undefined }, json: async () => ({ kind: "model-allowlist", version: 2 }) };
-  };
-
-  // Seed a cached kind so handlePolicyStale has a kind to refresh.
-  mkdirSync(join(root, "config", "cache", "policy"), { recursive: true });
-  writeFileSync(
-    join(root, "config", "cache", "policy", "model-allowlist.json"),
-    JSON.stringify({ kind: "model-allowlist", bundle: {}, verifiedAtMs: 1 }),
-  );
-
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client, fetchImpl,
-    setInterval: () => ({ unref() {} }),
-  });
-  const directives = await _internals.beatOnce(handle._ctx);
-  assert.deepEqual(directives, ["policy_stale"]);
-  assert.ok(policyFetchHits >= 1, "policy bundle was re-fetched on the policy_stale directive");
-  handle.stop();
-});
-
-test('"resync" directive refetches the directory into the local peers cache', async () => {
-  const root = tmpRepo();
-  const directory = [
-    { id: "robin-ai", name: "Robin", title: "Engineer" },
-    { id: "Sam-AI", name: "Sam", title: "CFO" },
-    { id: "", name: "ignore-me" }, // no id → skipped
-  ];
-  const client = fakeClient({ beatFrames: [{ ok: true, result: { directives: ["resync"] } }], directory });
-
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-  });
-  const directives = await _internals.beatOnce(handle._ctx);
-  assert.deepEqual(directives, ["resync"]);
-  assert.equal(client.directoryCalls.length, 1, "fetchDirectory was called once");
-
-  const peersDir = join(root, "state", "org", "peers");
-  const files = readdirSync(peersDir).sort();
-  assert.deepEqual(files, ["robin-ai.json", "sam-ai.json"], "two valid peers written, id sanitized/lowercased");
-  const robin = JSON.parse(readFileSync(join(peersDir, "robin-ai.json"), "utf8"));
-  assert.equal(robin.name, "Robin");
-  assert.equal(robin.source, "synced");
-  handle.stop();
-});
-
-test("org unreachable: presence beat that rejects never throws (fail-open)", async () => {
-  const root = tmpRepo();
-  const client = fakeClient();
-  client.presenceBeat = () => Promise.reject(new Error("ECONNREFUSED"));
-
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-  });
-  let directives;
-  await assert.doesNotReject(async () => { directives = await _internals.beatOnce(handle._ctx); });
-  assert.deepEqual(directives, [], "no directives acted on when the org is unreachable");
-  handle.stop();
-});
-
-test("a REJECTED beat (error frame, not a throw) is loudly warned, not silently ignored", async () => {
-  const root = tmpRepo();
-  // A refused beat resolves with an error FRAME — it does not throw — so the
-  // fail-open catch above never sees it. Before this was handled, an agent with
-  // a bad/empty token 401'd on every beat for the life of the process while
-  // logging nothing: it was not in the mesh, could not receive `halt`, and
-  // looked perfectly healthy.
-  const client = fakeClient({
-    beatFrames: [{ ok: false, error: { code: "UNAUTHORIZED", message: "bad key" } }],
-  });
-
-  const warnings = [];
-  const realWarn = console.warn;
-  console.warn = (...a) => { warnings.push(a.join(" ")); };
-  let directives;
-  try {
-    const handle = await connectOrgMesh({
-      agentRoot: root, cfg: cfgEnabled(), client,
-      setInterval: () => ({ unref() {} }),
-    });
-    directives = await _internals.beatOnce(handle._ctx);
-    handle.stop();
-  } finally {
-    console.warn = realWarn;
-  }
-
-  assert.deepEqual(directives, [], "a rejected beat yields no directives");
-  const warned = warnings.join("\n");
-  assert.match(warned, /REJECTED/, "the rejection must be logged, not swallowed");
-  assert.match(warned, /UNAUTHORIZED/, "the error code must reach the operator");
-  assert.match(warned, /COHORT_API_KEY/, "an auth failure must name the likely cause");
-});
-
-test("an accepted beat logs no rejection warning", async () => {
-  const root = tmpRepo();
-  const client = fakeClient({ beatFrames: [{ ok: true, result: { directives: [] } }] });
-  const warnings = [];
-  const realWarn = console.warn;
-  console.warn = (...a) => { warnings.push(a.join(" ")); };
-  try {
-    const handle = await connectOrgMesh({
-      agentRoot: root, cfg: cfgEnabled(), client,
-      setInterval: () => ({ unref() {} }),
-    });
-    await _internals.beatOnce(handle._ctx);
-    handle.stop();
-  } finally {
-    console.warn = realWarn;
-  }
-  assert.ok(
-    !warnings.join("\n").includes("REJECTED"),
-    "a healthy beat must not cry wolf",
-  );
-});
-
-test("registration failure at boot is swallowed; the mesh still comes up", async () => {
-  const root = tmpRepo();
-  const client = fakeClient();
-  client.register = () => Promise.reject(new Error("boom"));
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-  });
-  assert.equal(handle.isEnabled, true, "mesh handle is live despite a failed registration");
-  handle.stop();
-});
-
-test("stop() clears the interval and is idempotent", async () => {
-  const root = tmpRepo();
-  const client = fakeClient();
-  const cleared = [];
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {}, _id: 42 }),
-    clearInterval: (t) => cleared.push(t),
-  });
-  handle.stop();
-  handle.stop(); // idempotent — no second clear
-  assert.equal(cleared.length, 1, "clearInterval called exactly once");
-  assert.equal(cleared[0]._id, 42);
-});
-
-test("extractDirectives: filters to the known set + de-dupes", () => {
-  assert.deepEqual(
-    _internals.extractDirectives({ ok: true, result: { directives: ["resync", "resync", "bogus", "halt"] } }).sort(),
-    ["halt", "resync"],
-  );
-  assert.deepEqual(_internals.extractDirectives({ ok: false, error: { directive: "rotate_token" } }), ["rotate_token"]);
-  assert.deepEqual(_internals.extractDirectives({ ok: false, error: { directive: "nope" } }), []);
-  assert.deepEqual(_internals.extractDirectives(null), []);
-});
-
-test('"rotate_token" directive drops a re-pair flag', async () => {
-  const root = tmpRepo();
-  const client = fakeClient({ beatFrames: [{ ok: true, result: { directives: ["rotate_token"] } }] });
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-  });
-  await _internals.beatOnce(handle._ctx);
-  const flagPath = join(root, "state", "org", "repair-needed.json");
-  assert.ok(existsSync(flagPath), "repair-needed flag written");
-  const flag = JSON.parse(readFileSync(flagPath, "utf8"));
-  assert.equal(flag.reason, "rotate_token");
-  handle.stop();
-});
-
-test("presence beat attaches params.status from the injected collector", async () => {
-  const root = tmpRepo();
-  const client = fakeClient();
-  const fakeStatus = {
-    state: "busy", activity: "session: inbox", subAgentsRunning: 1, session: { id: "s1", taskClass: "inbox" },
-    machine: { loadavg: [1, 1, 1], memUsedPct: 40 }, claudeAuth: "ok", alerts: [], ts: "2026-06-12T12:00:00Z",
-  };
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-    collectStatus: async () => fakeStatus,
-  });
-  await _internals.beatOnce(handle._ctx);
-  assert.equal(client.beatCalls.length, 1);
-  assert.deepEqual(client.beatCalls[0].params.status, fakeStatus, "snapshot rides params.status");
-  handle.stop();
-});
-
-test("presence beat omits params.status when the collector throws (fail-open)", async () => {
-  const root = tmpRepo();
-  const client = fakeClient();
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-    collectStatus: async () => { throw new Error("collector boom"); },
-  });
-  let directives;
-  await assert.doesNotReject(async () => { directives = await _internals.beatOnce(handle._ctx); });
-  assert.deepEqual(directives, []);
-  assert.equal(client.beatCalls.length, 1, "beat still went out");
-  assert.equal("status" in client.beatCalls[0].params, false, "no status key when collection failed");
-  handle.stop();
-});
-
-test("a critical alert in the snapshot escalates locally (alert-critical flag)", async () => {
-  const root = tmpRepo();
-  const client = fakeClient();
-  const crit = {
-    state: "error", activity: "idle", subAgentsRunning: 0, session: null,
-    machine: { loadavg: [0, 0, 0], memUsedPct: 10 }, claudeAuth: "relogin_required",
-    alerts: [{ id: "claude_relogin_required", severity: "critical", kind: "auth", detail: "claude re-login required" }],
-    ts: "2026-06-12T12:00:00Z",
-  };
-  const handle = await connectOrgMesh({
-    agentRoot: root, cfg: cfgEnabled(), client,
-    setInterval: () => ({ unref() {} }),
-    collectStatus: async () => crit,
-  });
-  await _internals.beatOnce(handle._ctx);
-  const flagPath = join(root, "state", "org", "alert-critical.json");
-  assert.ok(existsSync(flagPath), "critical alert flag was written");
-  const flag = JSON.parse(readFileSync(flagPath, "utf8"));
-  assert.equal(flag.alerts[0].id, "claude_relogin_required");
-  // status still rides the beat too
-  assert.deepEqual(client.beatCalls[0].params.status, crit);
-  handle.stop();
-});
-
-test("loadOrgConfig reads config/org.yaml (the file the daemon + enrollment share) — config-source regression", async () => {
-  const { loadOrgConfig, isEnabled } = await import("./client.mjs");
-  const root = mkdtempSync(join(tmpdir(), "mesh-cfg-"));
-  try {
-    // No file → disabled (standalone), never throws.
-    assert.deepEqual(loadOrgConfig(root), {});
-    assert.equal(isEnabled(loadOrgConfig(root)), false);
-    // Enrolled config/org.yaml (exactly what sections/org.mjs writes) → enabled,
-    // and the daemon must resolve org config from HERE, not config/collective.yaml.
-    mkdirSync(join(root, "config"), { recursive: true });
-    writeFileSync(join(root, "config", "org.yaml"),
-      "org:\n  cohort:\n    enabled: true\n    base: https://cohort.example\n    orgId: o1\n    token: t1\n");
-    const cfg = loadOrgConfig(root);
-    assert.equal(isEnabled(cfg), true, "an enrolled agent is enabled via config/org.yaml");
-    assert.equal(cfg.org.cohort.base, "https://cohort.example");
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});