@agentoryhq/node 0.1.1

package/dist/daemon.e2e.test.js

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { once } from "node:events";
+import { test } from "node:test";
+/**
+ * AC-1 / AC-3 integration: real API (dist server, MemoryStore) + daemon --once
+ * through the real client path, fixture-driven asset index. Self-contained:
+ * boots its own API on an ephemeral port with a temp state dir.
+ */
+test("AC-1 + AC-3: daemon --once full round reports to server; second run skips unchanged index", async () => {
+    const { createApiServer } = await import("../../api/dist/server.js");
+    const { MemoryStore } = await import("../../api/dist/store.js");
+    const store = new MemoryStore();
+    const server = createApiServer(store);
+    server.listen(0, "127.0.0.1");
+    await once(server, "listening");
+    const port = server.address().port;
+    const base = `http://127.0.0.1:${port}`;
+    const bs = await fetch(`${base}/v1/bootstrap`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ email: "daemon-e2e@studio.dev" }),
+    });
+    const bsBody = (await bs.json());
+    const workspaceId = bsBody.workspace.id;
+    const reg = await fetch(`${base}/v1/nodes/register`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${bsBody.nodeRootToken}`, "content-type": "application/json" },
+        body: JSON.stringify({ name: "daemon-e2e", hostname: "e2e.local" }),
+    });
+    const regBody = (await reg.json());
+    const nodeId = regBody.node.id;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agentory-daemon-e2e-"));
+    const fixture = path.join(dir, "asset-index.json");
+    fs.writeFileSync(fixture, JSON.stringify({
+        sessions: [
+            { sourceKey: "s1", displayName: "daemon-e2e-session", projectPath: "/p", updatedAt: "2026-09-24T10:00:00Z" },
+        ],
+        memories: [],
+    }));
+    const prev = {
+        state: process.env.AGENTORY_NODE_STATE,
+        fixtureEnv: process.env.AGENTORY_ASSET_INDEX_FIXTURE,
+        cursorRoot: process.env.AGENTORY_CURSOR_ROOT,
+        base: process.env.CONTROL_PLANE_BASE_URL,
+    };
+    process.env.AGENTORY_NODE_STATE = path.join(dir, "node.json");
+    // daemon 的去重 state 文件落在 state 同目录（daemon-state.json）
+    process.env.AGENTORY_ASSET_INDEX_FIXTURE = fixture;
+    process.env.AGENTORY_CURSOR_ROOT = dir;
+    process.env.CONTROL_PLANE_BASE_URL = base;
+    try {
+        const { runDaemon } = await import("./daemon.js");
+        fs.writeFileSync(path.join(dir, "node.json"), JSON.stringify({ workspaceId, nodeId, nodeToken: regBody.nodeToken, controlPlaneBaseUrl: base }));
+        const capture = () => {
+            const lines = [];
+            const orig = console.log;
+            console.log = (...args) => {
+                lines.push(args.map(String).join(" "));
+            };
+            return {
+                lines,
+                restore: () => {
+                    console.log = orig;
+                },
+            };
+        };
+        // Round 1: heartbeat + align + asset-index + discover all ok.
+        const c1 = capture();
+        let code1;
+        try {
+            code1 = await runDaemon({ once: true });
+        }
+        finally {
+            c1.restore();
+        }
+        assert.equal(code1, 0, "first --once should succeed");
+        assert.ok(c1.lines.some((l) => l.includes('"channel":"heartbeat"') && l.includes('"ok"')), "heartbeat ok");
+        assert.ok(c1.lines.some((l) => l.includes('"channel":"asset-index"') && l.includes('"ok"')), "asset-index posted");
+        // Server side: session index now contains the fixture session for this node.
+        const idx = await fetch(`${base}/v1/workspaces/${workspaceId}/session-index?q=daemon-e2e-session`, {
+            headers: { authorization: `Bearer ${bsBody.sessionToken}` },
+        });
+        const idxBody = (await idx.json());
+        assert.equal(idx.status, 200);
+        assert.ok(idxBody.sessions.some((s) => s.displayName === "daemon-e2e-session"), "fixture session visible in session-index");
+        // Round 2: index unchanged → skip; heartbeat still fires.
+        const c2 = capture();
+        let code2;
+        try {
+            code2 = await runDaemon({ once: true });
+        }
+        finally {
+            c2.restore();
+        }
+        assert.equal(code2, 0, "second --once should succeed (heartbeat goes, index skips)");
+        assert.ok(c2.lines.some((l) => l.includes("unchanged, skip")), "asset-index unchanged, skip");
+        assert.ok(c2.lines.some((l) => l.includes('"channel":"heartbeat"') && l.includes('"ok"')), "heartbeat still ok");
+    }
+    finally {
+        if (prev.state === undefined)
+            delete process.env.AGENTORY_NODE_STATE;
+        else
+            process.env.AGENTORY_NODE_STATE = prev.state;
+        if (prev.fixtureEnv === undefined)
+            delete process.env.AGENTORY_ASSET_INDEX_FIXTURE;
+        else
+            process.env.AGENTORY_ASSET_INDEX_FIXTURE = prev.fixtureEnv;
+        if (prev.cursorRoot === undefined)
+            delete process.env.AGENTORY_CURSOR_ROOT;
+        else
+            process.env.AGENTORY_CURSOR_ROOT = prev.cursorRoot;
+        if (prev.base === undefined)
+            delete process.env.CONTROL_PLANE_BASE_URL;
+        else
+            process.env.CONTROL_PLANE_BASE_URL = prev.base;
+        fs.rmSync(dir, { recursive: true, force: true });
+        server.close();
+        await once(server, "close");
+    }
+});

package/dist/daemon.js

@@ -0,0 +1,223 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { controlPlaneBaseUrl } from "@agentoryhq/shared";
+import { applyPendingAligns, fulfillPendingTranscripts, heartbeat, loadState, reportAssetIndex, reportDiscovery } from "./client.js";
+import { discoverAssetIndex } from "./asset-index.js";
+const MIN_INTERVAL_SEC = 5;
+const DEFAULTS = {
+    heartbeatSec: 60,
+    indexSec: 600,
+    discoverSec: 3600,
+};
+function logLine(stream, channel, status, detail) {
+    stream(JSON.stringify({ ts: new Date().toISOString(), channel, status, ...detail }));
+}
+/** Env override with hard clamp to MIN_INTERVAL_SEC (AC-6). */
+export function parseIntervalSec(envName, fallback) {
+    const raw = process.env[envName];
+    if (raw === undefined)
+        return fallback;
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed) && parsed >= MIN_INTERVAL_SEC)
+        return Math.floor(parsed);
+    if (!Number.isFinite(parsed) || parsed !== MIN_INTERVAL_SEC) {
+        // 只对真被钳制的值打日志（含 0/负数/非数字；不重复日志 0 会被钳到 5）
+        logLine(console.error, "daemon", "clamped", { message: `${envName}=${raw} clamped to ${MIN_INTERVAL_SEC}sec` });
+    }
+    return MIN_INTERVAL_SEC;
+}
+export function resolveIntervals() {
+    return {
+        heartbeatSec: parseIntervalSec("AGENTORY_DAEMON_HEARTBEAT_SEC", DEFAULTS.heartbeatSec),
+        indexSec: parseIntervalSec("AGENTORY_DAEMON_INDEX_SEC", DEFAULTS.indexSec),
+        discoverSec: parseIntervalSec("AGENTORY_DAEMON_DISCOVER_SEC", DEFAULTS.discoverSec),
+    };
+}
+/** 0–10% of the period of jitter, so a fleet of nodes doesn't fire in unison. */
+export function jitterMs(periodSec, rand = Math.random) {
+    return Math.floor(rand() * 0.1 * periodSec * 1000);
+}
+export function assetIndexSha(index) {
+    return createHash("sha256").update(JSON.stringify(index)).digest("hex");
+}
+function daemonStateFile() {
+    return process.env.AGENTORY_NODE_STATE
+        ? path.join(path.dirname(process.env.AGENTORY_NODE_STATE), "daemon-state.json")
+        : path.join(os.homedir(), ".agentory", "daemon-state.json");
+}
+function loadDaemonState() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(daemonStateFile(), "utf8"));
+        if (raw && typeof raw === "object")
+            return raw;
+    }
+    catch {
+        /* fresh start */
+    }
+    return {};
+}
+function saveDaemonState(state) {
+    const file = daemonStateFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(state, null, 2), { mode: 0o600 });
+}
+const daemonState = loadDaemonState();
+/** Report the index only when its content hash changed since last report (AC-3). */
+export async function reportAssetIndexIfChanged() {
+    const sha = assetIndexSha(discoverAssetIndex());
+    if (daemonState.lastIndexSha === sha) {
+        logLine(console.log, "asset-index", "unchanged, skip", { sha: sha.slice(0, 12) });
+        return 0;
+    }
+    const code = await reportAssetIndex();
+    if (code === 0) {
+        daemonState.lastIndexSha = sha;
+        saveDaemonState(daemonState);
+    }
+    return code;
+}
+let heartbeatFailures = 0;
+async function runChannel(name, fn, onExit) {
+    try {
+        const code = await fn();
+        if (name === "heartbeat") {
+            heartbeatFailures = code === 0 ? 0 : heartbeatFailures + 1;
+            if (heartbeatFailures >= 3) {
+                logLine(console.error, "daemon", "heartbeat failing", { consecutiveFailures: heartbeatFailures });
+            }
+        }
+        logLine(console.log, name, code === 0 ? "ok" : "error", code === 0 ? undefined : { exit: code });
+        if (code !== 0 && onExit)
+            onExit(code);
+    }
+    catch (err) {
+        // 单轮失败不退进程（AC-4）——结构化错误行，继续下一个通道/下一轮。
+        logLine(console.error, name, "error", { error: err instanceof Error ? err.message : String(err), base: controlPlaneBaseUrl() });
+        if (onExit)
+            onExit(1);
+    }
+}
+/** One full round: all channels (--once 与首轮同语义，AC-1）。失败通道 → 非 0。 */
+export async function runFullRound() {
+    let code = 0;
+    await runChannel("heartbeat", heartbeat, (c) => {
+        if (c !== 0)
+            code = c;
+    });
+    await runChannel("align", applyPendingAligns, (c) => {
+        if (c !== 0)
+            code = c;
+    });
+    await runChannel("asset-index", reportAssetIndexIfChanged, (c) => {
+        if (c !== 0)
+            code = c;
+    });
+    await runChannel("transcript", fulfillPendingTranscripts, (c) => {
+        if (c !== 0)
+            code = c;
+    });
+    await runChannel("discover", reportDiscovery, (c) => {
+        if (c !== 0)
+            code = c;
+    });
+    return code;
+}
+export async function runDaemon(opts = {}) {
+    const st = loadState();
+    if (!st) {
+        console.error("not registered; run: agentory-node register --token <root>");
+        return 2;
+    }
+    const intervals = { ...resolveIntervals(), ...(opts.intervals ?? {}) };
+    logLine(console.log, "daemon", "start", {
+        nodeId: st.nodeId,
+        heartbeatSec: intervals.heartbeatSec,
+        indexSec: intervals.indexSec,
+        discoverSec: intervals.discoverSec,
+        once: !!opts.once,
+    });
+    if (opts.once) {
+        // 第一轮前先探活：控制面不可达时 --once 应失败退出非 0（AC-4），
+        // 常驻模式则靠 runChannel 的容错继续重试。
+        try {
+            const res = await fetch(`${controlPlaneBaseUrl()}/health`);
+            if (!res.ok) {
+                logLine(console.error, "daemon", "unreachable", { base: controlPlaneBaseUrl(), status: res.status });
+                return 1;
+            }
+        }
+        catch (err) {
+            logLine(console.error, "daemon", "unreachable", {
+                base: controlPlaneBaseUrl(),
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return 1;
+        }
+        const code = await runFullRound();
+        logLine(console.log, "daemon", "stop", { reason: "once" });
+        return code;
+    }
+    const sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const clock = opts.clock ?? (() => Date.now());
+    const startedAt = clock();
+    let stopping = false;
+    const onSignal = (sig) => {
+        if (stopping)
+            return;
+        stopping = true;
+        logLine(console.log, "daemon", "stopping", { signal: sig });
+    };
+    if (opts.registerSignal) {
+        opts.registerSignal(onSignal);
+    }
+    else {
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+    }
+    // Anti-flap jitter（防整点齐射）；进程收到信号时 jumping out。
+    try {
+        const j = jitterMs(intervals.heartbeatSec);
+        if (j > 0) {
+            logLine(console.log, "daemon", "jitter", { ms: j });
+            await sleep(j);
+        }
+    }
+    catch {
+        /* sleep aborted（少见；继续） */
+    }
+    const nextDue = {
+        heartbeat: startedAt + intervals.heartbeatSec * 1000,
+        index: startedAt + intervals.indexSec * 1000,
+        discover: startedAt + intervals.discoverSec * 1000,
+    };
+    while (!stopping) {
+        const now = clock();
+        if (now >= nextDue.heartbeat) {
+            await runChannel("heartbeat", heartbeat);
+            await runChannel("align", applyPendingAligns);
+            await runChannel("transcript", fulfillPendingTranscripts);
+            nextDue.heartbeat += intervals.heartbeatSec * 1000;
+        }
+        if (now >= nextDue.index) {
+            await runChannel("asset-index", reportAssetIndexIfChanged);
+            nextDue.index += intervals.indexSec * 1000;
+        }
+        if (now >= nextDue.discover) {
+            await runChannel("discover", reportDiscovery);
+            nextDue.discover += intervals.discoverSec * 1000;
+        }
+        // 睡到最近一个到期点（信号会被 stopping 吸收，醒来即退）。
+        const wakeAt = Math.min(nextDue.heartbeat, nextDue.index, nextDue.discover);
+        const ms = Math.max(0, wakeAt - clock());
+        try {
+            await ms > 0 ? sleep(ms) : sleep(0);
+        }
+        catch {
+            /* sleep aborted */
+        }
+    }
+    logLine(console.log, "daemon", "stop", { reason: "signal" });
+    return 0;
+}

package/dist/daemon.test.d.ts

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

package/dist/daemon.test.js

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { assetIndexSha, jitterMs, parseIntervalSec, resolveIntervals, runDaemon, } from "./daemon.js";
+function tmpStateDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "agentory-daemon-test-"));
+}
+function writeState(dir) {
+    const file = path.join(dir, "node.json");
+    fs.writeFileSync(file, JSON.stringify({ nodeId: "nd_test", nodeToken: "tok_test", controlPlaneBaseUrl: "http://127.0.0.1:1" }, null, 2), { mode: 0o600 });
+    return file;
+}
+test("AC-6: interval clamps to minimum (0 and non-numeric)", () => {
+    process.env.AGENTORY_DAEMON_HEARTBEAT_SEC = "0";
+    assert.equal(parseIntervalSec("AGENTORY_DAEMON_HEARTBEAT_SEC", 60), 5);
+    delete process.env.AGENTORY_DAEMON_HEARTBEAT_SEC;
+    process.env.AGENTORY_DAEMON_INDEX_SEC = "abc";
+    assert.equal(parseIntervalSec("AGENTORY_DAEMON_INDEX_SEC", 600), 5);
+    delete process.env.AGENTORY_DAEMON_INDEX_SEC;
+    // negative also clamps
+    process.env.AGENTORY_DAEMON_DISCOVER_SEC = "-3";
+    assert.equal(parseIntervalSec("AGENTORY_DAEMON_DISCOVER_SEC", 3600), 5);
+    delete process.env.AGENTORY_DAEMON_DISCOVER_SEC;
+    // valid values pass through
+    assert.equal(parseIntervalSec("AGENTORY_DAEMON_HEARTBEAT_SEC", 60), 60);
+});
+test("AC-6: resolveIntervals reports clamped values", () => {
+    const savedHb = process.env.AGENTORY_DAEMON_HEARTBEAT_SEC;
+    process.env.AGENTORY_DAEMON_HEARTBEAT_SEC = "0";
+    const iv = resolveIntervals();
+    assert.equal(iv.heartbeatSec, 5);
+    assert.equal(iv.indexSec, 600);
+    assert.equal(iv.discoverSec, 3600);
+    if (savedHb === undefined)
+        delete process.env.AGENTORY_DAEMON_HEARTBEAT_SEC;
+    else
+        process.env.AGENTORY_DAEMON_HEARTBEAT_SEC = savedHb;
+});
+test("jitter stays within 10% of period (deterministic bounds)", () => {
+    for (let i = 0; i < 50; i++) {
+        const j = jitterMs(100, () => 0.999);
+        assert.ok(j >= 0 && j < 10 * 1000, `jitter out of bounds: ${j}`);
+    }
+    assert.equal(jitterMs(100, () => 0), 0);
+});
+test("assetIndexSha changes when index changes", () => {
+    const a = assetIndexSha({ sessions: [{ id: 1 }], memories: [] });
+    const b = assetIndexSha({ sessions: [{ id: 2 }], memories: [] });
+    assert.notEqual(a, b);
+    assert.equal(a, assetIndexSha({ sessions: [{ id: 1 }], memories: [] }));
+});
+test("AC-4 (part): daemon --once exits non-zero when control plane unreachable, base URL in stderr/log", async () => {
+    const dir = tmpStateDir();
+    const prev = process.env.AGENTORY_NODE_STATE;
+    const prevBase = process.env.CONTROL_PLANE_BASE_URL;
+    process.env.AGENTORY_NODE_STATE = writeState(dir);
+    process.env.CONTROL_PLANE_BASE_URL = "http://127.0.0.1:1"; // 不可达端口
+    try {
+        const code = await runDaemon({ once: true });
+        assert.notEqual(code, 0);
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.AGENTORY_NODE_STATE;
+        else
+            process.env.AGENTORY_NODE_STATE = prev;
+        if (prevBase === undefined)
+            delete process.env.CONTROL_PLANE_BASE_URL;
+        else
+            process.env.CONTROL_PLANE_BASE_URL = prevBase;
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("daemon without registration exits 2 with usage hint", async () => {
+    const dir = tmpStateDir();
+    const prev = process.env.AGENTORY_NODE_STATE;
+    process.env.AGENTORY_NODE_STATE = path.join(dir, "missing.json");
+    try {
+        const code = await runDaemon({ once: true });
+        assert.equal(code, 2);
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.AGENTORY_NODE_STATE;
+        else
+            process.env.AGENTORY_NODE_STATE = prev;
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("AC-5: SIGNAL mid-run → graceful stop, exit 0", async () => {
+    const dir = tmpStateDir();
+    const prev = process.env.AGENTORY_NODE_STATE;
+    process.env.AGENTORY_NODE_STATE = writeState(dir);
+    let fireSignal;
+    let sawStoppingLine = false;
+    const originalLog = console.log;
+    console.log = (...args) => {
+        const s = args.map(String).join(" ");
+        if (s.includes('"stopping"'))
+            sawStoppingLine = true;
+        originalLog(...args);
+    };
+    try {
+        let elapsedMs = 0;
+        const code = await runDaemon({
+            intervals: { heartbeatSec: 5, indexSec: 600, discoverSec: 3600 },
+            clock: () => 1_000 + elapsedMs,
+            sleep: (ms) => {
+                elapsedMs += ms;
+                if (elapsedMs >= 5_000 && fireSignal) {
+                    fireSignal("SIGINT");
+                }
+                return new Promise((r) => setTimeout(r, 0));
+            },
+            registerSignal: (onSignal) => {
+                fireSignal = onSignal;
+            },
+        });
+        assert.equal(code, 0);
+        assert.ok(sawStoppingLine, "expected a stopping log line on signal");
+    }
+    finally {
+        console.log = originalLog;
+        if (prev === undefined)
+            delete process.env.AGENTORY_NODE_STATE;
+        else
+            process.env.AGENTORY_NODE_STATE = prev;
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});

package/dist/discover.d.ts

@@ -0,0 +1,14 @@
+import type { DiscoveredAgent } from "@agentoryhq/shared";
+export type DiscoverOpts = {
+    /** Override home for tests. */
+    homeDir?: string;
+    /** Optional JSON fixture path (AGENTORY_DISCOVERY_FIXTURE). */
+    fixturePath?: string;
+    cwd?: string;
+    /** Skip probe (unit tests of filesystem parse only). */
+    skipProbe?: boolean;
+};
+/** Sync filesystem/fixture discovery (no probe). */
+export declare function discoverAgents(opts?: DiscoverOpts): DiscoveredAgent[];
+/** Discovery + binding-level health probe (AC-2). */
+export declare function discoverAgentsWithHealth(opts?: DiscoverOpts): Promise<DiscoveredAgent[]>;

package/dist/discover.js

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import os from "node:os";
+import { probeAll } from "./probe.js";
+import { builtinAdapters } from "./registry.js";
+function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function adapterContext(opts) {
+    return {
+        homeDir: opts.homeDir ?? os.homedir(),
+        cwd: opts.cwd ?? process.cwd(),
+    };
+}
+function discoverAgentsSync(opts = {}) {
+    const fixture = opts.fixturePath ?? process.env.AGENTORY_DISCOVERY_FIXTURE;
+    if (fixture) {
+        const raw = readJsonFile(fixture);
+        if (Array.isArray(raw))
+            return raw;
+        if (raw && typeof raw === "object" && Array.isArray(raw.agents)) {
+            return raw.agents;
+        }
+    }
+    const ctx = adapterContext(opts);
+    const agents = [];
+    for (const adapter of builtinAdapters) {
+        if (!adapter.detect(ctx))
+            continue;
+        if (adapter.discoverConfig) {
+            const agent = adapter.discoverConfig(ctx);
+            if (agent)
+                agents.push(agent);
+        }
+    }
+    return agents;
+}
+/** Sync filesystem/fixture discovery (no probe). */
+export function discoverAgents(opts = {}) {
+    return discoverAgentsSync(opts);
+}
+/** Discovery + binding-level health probe (AC-2). */
+export async function discoverAgentsWithHealth(opts = {}) {
+    const agents = discoverAgentsSync(opts);
+    if (opts.skipProbe)
+        return agents;
+    return Promise.all(agents.map(async (a) => {
+        if (!a.mcp.length)
+            return a;
+        const mcp = await probeAll(a.mcp.map((m) => ({ name: m.name, command: m.command })));
+        return { ...a, mcp };
+    }));
+}

package/dist/discover.test.d.ts

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

package/dist/discover.test.js

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { discoverAgents, discoverAgentsWithHealth } from "./discover.js";
+test("discover cursor mcp and empty skills; claude supported", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-disc-"));
+    const home = path.join(root, "home");
+    const cwd = path.join(root, "proj");
+    fs.mkdirSync(path.join(cwd, ".cursor"), { recursive: true });
+    fs.writeFileSync(path.join(cwd, ".cursor", "mcp.json"), JSON.stringify({
+        mcpServers: {
+            github: { command: "npx", args: ["-y", "server"] },
+        },
+    }));
+    fs.mkdirSync(path.join(home, ".claude"), { recursive: true });
+    const agents = discoverAgents({ homeDir: home, cwd });
+    const cursor = agents.find((a) => a.runtime === "cursor");
+    const claude = agents.find((a) => a.runtime === "claude-code");
+    assert.ok(cursor);
+    assert.equal(cursor.supported, true);
+    assert.equal(cursor.mcp.length, 1);
+    assert.equal(cursor.mcp[0]?.name, "github");
+    assert.equal(cursor.mcp[0]?.status, "unknown");
+    assert.deepEqual(cursor.skills, []);
+    assert.ok(claude);
+    assert.equal(claude.supported, true);
+});
+test("discoverAgentsWithHealth probes bindings", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-disc-h-"));
+    const home = path.join(root, "home");
+    const cwd = path.join(root, "proj");
+    fs.mkdirSync(path.join(cwd, ".cursor"), { recursive: true });
+    fs.writeFileSync(path.join(cwd, ".cursor", "mcp.json"), JSON.stringify({
+        mcpServers: {
+            broken: { command: "npx", args: ["invalid", "bad-url"] },
+            ok: { command: "npx", args: ["-y", "server"] },
+        },
+    }));
+    const agents = await discoverAgentsWithHealth({ homeDir: home, cwd });
+    const cursor = agents.find((a) => a.runtime === "cursor");
+    assert.ok(cursor);
+    const broken = cursor.mcp.find((m) => m.name === "broken");
+    const ok = cursor.mcp.find((m) => m.name === "ok");
+    assert.equal(broken?.status, "failed");
+    assert.ok(broken?.reason);
+    assert.equal(ok?.status, "healthy");
+});
+test("discover includes ~/.cursor/skills-cursor names", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-skills-"));
+    const home = path.join(root, "home");
+    const cwd = path.join(root, "proj");
+    fs.mkdirSync(path.join(cwd, ".cursor"), { recursive: true });
+    fs.mkdirSync(path.join(home, ".cursor", "skills-cursor", "native-skill"), { recursive: true });
+    fs.writeFileSync(path.join(home, ".cursor", "skills-cursor", "native-skill", "SKILL.md"), "# native\n");
+    const agents = discoverAgents({ homeDir: home, cwd });
+    const cursor = agents.find((a) => a.runtime === "cursor");
+    assert.ok(cursor);
+    assert.ok(cursor.skills.includes("native-skill"));
+});
+test("fixture overrides filesystem", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-fix-"));
+    const fixture = path.join(root, "fix.json");
+    fs.writeFileSync(fixture, JSON.stringify({
+        agents: [
+            {
+                runtime: "cursor",
+                supported: true,
+                displayName: "Cursor · fixture",
+                mcp: [],
+                skills: [],
+            },
+        ],
+    }));
+    const agents = discoverAgents({ fixturePath: fixture, homeDir: root, cwd: root });
+    assert.equal(agents.length, 1);
+    assert.equal(agents[0]?.mcp.length, 0);
+});

package/dist/probe.d.ts

@@ -0,0 +1,18 @@
+import type { LiveMcpBinding, McpHealthStatus } from "@agentoryhq/shared";
+export type ProbeInput = {
+    name: string;
+    command?: string;
+};
+/**
+ * Binding-level health probe (slice 3 / AC-2).
+ * Simulation hooks in command string for tests: invalid / ENOENT / timeout-sim / degraded.
+ * Optional real HTTP(S) fetch when command looks like a URL and AGENTORY_MCP_HTTP_PROBE=1.
+ */
+export declare function probeMcpBinding(input: ProbeInput, opts?: {
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}): Promise<LiveMcpBinding>;
+export declare function probeAll(bindings: ProbeInput[], opts?: {
+    timeoutMs?: number;
+}): Promise<LiveMcpBinding[]>;
+export declare function worstStatus(statuses: McpHealthStatus[]): McpHealthStatus;