@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/unit/connectors/evomap-runner.test.js

@@ -0,0 +1,136 @@
+/**
+ * T-CS.C.10 — EvoMap runner unit tests.
+ *
+ * Verifies createEvoMapRunner with mock clients:
+ * - agent.register saves node_secret via a2a
+ * - agent.heartbeat sends api request with node_secret
+ * - work.discover uses a2a channel
+ * - task.claim uses api_rest channel
+ * - unsupported intent throws protocol_mismatch
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createEvoMapRunner } from "../../../src/connectors/agent-network/evomap/adapter.js";
+function makePlan(intent, channel) {
+    return {
+        platformId: "evomap",
+        intent: intent,
+        channel,
+        endpointMode: channel === "a2a" ? "a2a_envelope" : "rest_json",
+        degraded: channel === "skill",
+    };
+}
+function makeRequest(intent) {
+    return {
+        platformId: "evomap",
+        intent: intent,
+        payload: {},
+        decisionId: "dec-1",
+        intentId: "intent-1",
+        idempotencyKey: `idem-${intent}`,
+    };
+}
+test("T-CS.C.10-A: agent.register via a2a saves node_secret", async () => {
+    let savedSecret = null;
+    const secretPort = {
+        async loadNodeSecret() { return savedSecret; },
+        async saveNodeSecret(_platformId, nodeSecret) { savedSecret = nodeSecret; },
+    };
+    const a2aClient = {
+        async helloOrRegister() {
+            return { your_node_id: "node-123", node_secret: "secret-abc" };
+        },
+        async discoverWork() { throw new Error("unexpected"); },
+    };
+    const runner = createEvoMapRunner({ apiClient: { async heartbeat() { throw new Error("unexpected"); }, async claimTask() { throw new Error("unexpected"); } }, a2aClient, secretPort });
+    const result = await runner.run(makePlan("agent.register", "a2a"), makeRequest("agent.register"));
+    assert.equal(result.success, true);
+    assert.equal(savedSecret, "secret-abc");
+});
+test("T-CS.C.10-B: agent.heartbeat via api_rest with node_secret", async () => {
+    const secretPort = {
+        async loadNodeSecret() { return "secret-xyz"; },
+        async saveNodeSecret() { },
+    };
+    let heartbeatPayload = null;
+    let heartbeatSecret = null;
+    const apiClient = {
+        async heartbeat(payload, nodeSecret) {
+            heartbeatPayload = payload;
+            heartbeatSecret = nodeSecret;
+            return { status: "ok", timestamp: "2026-05-29T00:00:00Z" };
+        },
+        async claimTask() { throw new Error("unexpected"); },
+    };
+    const runner = createEvoMapRunner({ apiClient, a2aClient: { async helloOrRegister() { throw new Error("unexpected"); }, async discoverWork() { throw new Error("unexpected"); } }, secretPort });
+    const result = await runner.run(makePlan("agent.heartbeat", "api_rest"), makeRequest("agent.heartbeat"));
+    assert.equal(result.success, true);
+    assert.equal(heartbeatSecret, "secret-xyz");
+});
+test("T-CS.C.10-C: work.discover via a2a with node_secret", async () => {
+    const secretPort = {
+        async loadNodeSecret() { return "secret-discover"; },
+        async saveNodeSecret() { },
+    };
+    let discoverSecret = null;
+    const a2aClient = {
+        async helloOrRegister() { throw new Error("unexpected"); },
+        async discoverWork(_payload, nodeSecret) {
+            discoverSecret = nodeSecret;
+            return { tasks: [{ id: "task-1" }] };
+        },
+    };
+    const runner = createEvoMapRunner({ apiClient: { async heartbeat() { throw new Error("unexpected"); }, async claimTask() { throw new Error("unexpected"); } }, a2aClient, secretPort });
+    const result = await runner.run(makePlan("work.discover", "a2a"), makeRequest("work.discover"));
+    assert.equal(result.success, true);
+    assert.equal(discoverSecret, "secret-discover");
+});
+test("T-CS.C.10-D: task.claim via api_rest with node_secret", async () => {
+    const secretPort = {
+        async loadNodeSecret() { return "secret-claim"; },
+        async saveNodeSecret() { },
+    };
+    let claimSecret = null;
+    const apiClient = {
+        async heartbeat() { throw new Error("unexpected"); },
+        async claimTask(_payload, nodeSecret) {
+            claimSecret = nodeSecret;
+            return { claimed: true, taskId: "task-99" };
+        },
+    };
+    const runner = createEvoMapRunner({ apiClient, a2aClient: { async helloOrRegister() { throw new Error("unexpected"); }, async discoverWork() { throw new Error("unexpected"); } }, secretPort });
+    const result = await runner.run(makePlan("task.claim", "api_rest"), makeRequest("task.claim"));
+    assert.equal(result.success, true);
+    assert.equal(claimSecret, "secret-claim");
+});
+test("T-CS.C.10-E: missing node_secret throws verification_required", async () => {
+    const secretPort = {
+        async loadNodeSecret() { return null; },
+        async saveNodeSecret() { },
+    };
+    const runner = createEvoMapRunner({
+        apiClient: { async heartbeat() { throw new Error("unexpected"); }, async claimTask() { throw new Error("unexpected"); } },
+        a2aClient: { async helloOrRegister() { throw new Error("unexpected"); }, async discoverWork() { throw new Error("unexpected"); } },
+        secretPort,
+    });
+    const result = await runner.run(makePlan("agent.heartbeat", "api_rest"), makeRequest("agent.heartbeat"));
+    assert.equal(result.success, false);
+    const error = result.error;
+    assert.equal(error.code, "verification_required");
+    assert.equal(error.detail, "node_secret_required");
+});
+test("T-CS.C.10-F: unsupported intent throws protocol_mismatch", async () => {
+    const secretPort = {
+        async loadNodeSecret() { return "secret"; },
+        async saveNodeSecret() { },
+    };
+    const runner = createEvoMapRunner({
+        apiClient: { async heartbeat() { throw new Error("unexpected"); }, async claimTask() { throw new Error("unexpected"); } },
+        a2aClient: { async helloOrRegister() { throw new Error("unexpected"); }, async discoverWork() { throw new Error("unexpected"); } },
+        secretPort,
+    });
+    const result = await runner.run(makePlan("feed.read", "api_rest"), { ...makeRequest("feed.read"), platformId: "evomap" });
+    assert.equal(result.success, false);
+    const error = result.error;
+    assert.equal(error.code, "protocol_mismatch");
+});

package/dist/tests/unit/connectors/execution-policy.test.d.ts

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

package/dist/tests/unit/connectors/execution-policy.test.js

@@ -0,0 +1,71 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { enforceExecutionPolicy, InMemoryEffectCommitLedger, classifyConnectorIntentEffect, } from "../../../src/connectors/base/execution-policy.js";
+import { ConnectorPolicyError } from "../../../src/connectors/base/failure-taxonomy.js";
+const baseRequest = {
+    platformId: "p1",
+    intent: "message.send",
+    payload: {},
+    decisionId: "dec-1",
+    intentId: "int-1",
+};
+test("T3.2.1 side_effect without idempotency key is terminal policy failure", async () => {
+    const plan = {
+        platformId: "p1",
+        intent: "message.send",
+        channel: "api_rest",
+        endpointMode: "rest_json",
+        degraded: false,
+    };
+    await assert.rejects(() => enforceExecutionPolicy(plan, "message.send", baseRequest, {}), (e) => e instanceof ConnectorPolicyError && e.failureClass === "permanent_input_error");
+});
+test("T3.2.1 degraded channel blocks side_effect even with idempotency key", async () => {
+    const plan = {
+        platformId: "p1",
+        intent: "message.send",
+        channel: "cli",
+        endpointMode: "cli_stdout",
+        idempotencyKey: "idem-1",
+        degraded: true,
+    };
+    await assert.rejects(() => enforceExecutionPolicy(plan, "message.send", { ...baseRequest, idempotencyKey: "idem-1" }, {}), (e) => e instanceof ConnectorPolicyError && e.failureClass === "semantic_rejection");
+});
+test("T3.2.1 committed idempotency key skips adapter (replay)", async () => {
+    const ledger = new InMemoryEffectCommitLedger();
+    ledger.seedCommitted("dec-1", "idem-replay", "outcome:prev");
+    const plan = {
+        platformId: "p1",
+        intent: "message.send",
+        channel: "api_rest",
+        endpointMode: "rest_json",
+        idempotencyKey: "idem-replay",
+        degraded: false,
+    };
+    const gate = await enforceExecutionPolicy(plan, "message.send", { ...baseRequest, idempotencyKey: "idem-replay" }, {
+        effectCommitLedger: ledger,
+    });
+    assert.equal(gate.skipAdapter, true);
+    assert.equal(gate.existingOutcomeRef, "outcome:prev");
+});
+test("T3.2.1 dispatched state requires reconcile", async () => {
+    const ledger = new InMemoryEffectCommitLedger();
+    await ledger.getOrCreateIntentCommitRecord({
+        decisionId: "dec-1",
+        intentId: "int-1",
+        idempotencyKey: "idem-disp",
+        effectClass: "side_effect",
+    });
+    ledger.markState("dec-1", "idem-disp", "dispatched");
+    const plan = {
+        platformId: "p1",
+        intent: "message.send",
+        channel: "api_rest",
+        endpointMode: "rest_json",
+        idempotencyKey: "idem-disp",
+        degraded: false,
+    };
+    await assert.rejects(() => enforceExecutionPolicy(plan, "message.send", { ...baseRequest, idempotencyKey: "idem-disp" }, { effectCommitLedger: ledger }), (e) => e instanceof ConnectorPolicyError && e.failureClass === "concurrency_conflict");
+});
+test("T3.2.1 classify feed.read as read_only", () => {
+    assert.equal(classifyConnectorIntentEffect("feed.read"), "read_only");
+});

package/dist/tests/unit/connectors/instreet-registration.test.d.ts

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

package/dist/tests/unit/connectors/instreet-registration.test.js

@@ -0,0 +1,102 @@
+/**
+ * T-CS.C.9 — Instreet connector registration + platform_unavailable marking.
+ *
+ * Verifies:
+ * A. instreet manifest is registered in the executor adapter registry.
+ * B. instreet execution returns structured platform_unavailable (not unknown_platform).
+ * C. compile check passes.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { createConnectorExecutorAdapter } from "../../../src/connectors/services/connector-executor-adapter.js";
+import { createCredentialVault } from "../../../src/storage/services/credential-vault.js";
+import { CapabilityContractRegistry } from "../../../src/connectors/base/manifest.js";
+import { instreetManifest } from "../../../src/connectors/social-community/instreet/manifest.js";
+const ORIGINAL_KEY = process.env.SECOND_NATURE_ENCRYPTION_KEY;
+test.beforeEach(() => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
+});
+test.afterEach(() => {
+    if (ORIGINAL_KEY === undefined)
+        delete process.env.SECOND_NATURE_ENCRYPTION_KEY;
+    else
+        process.env.SECOND_NATURE_ENCRYPTION_KEY = ORIGINAL_KEY;
+});
+async function seedCredential(stateDb) {
+    const vault = createCredentialVault(stateDb.db);
+    await vault.saveCredentialContext({
+        platformId: "instreet",
+        credentialType: "api_key",
+        encryptedValue: "mock-token",
+        status: "active",
+    });
+}
+test("T-CS.C.9-A: instreet manifest resolves capability in registry", () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({ ...instreetManifest });
+    const resolved = registry.resolveCapability("notification.list", "instreet");
+    assert.ok(resolved, "instreet notification.list must resolve");
+    assert.equal(resolved.platformId, "instreet");
+    assert.equal(resolved.intent, "notification.list");
+    assert.ok(registry.hasCapability("instreet", "message.send"), "instreet must support message.send");
+    assert.ok(!registry.hasCapability("instreet", "nonexistent.capability"), "nonexistent capability must not be supported");
+});
+test("T-CS.C.9-B: instreet execution returns platform_unavailable", async () => {
+    const emptyWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), "sn-instreet-"));
+    try {
+        const stateDb = createStateDatabase(":memory:");
+        const observabilityDb = createObservabilityDatabase(":memory:");
+        await seedCredential(stateDb);
+        const executor = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot: emptyWorkspace,
+        });
+        const result = await executor.executeEffect({
+            intent: "notification.list",
+            platformId: "instreet",
+            payload: {},
+            decisionId: "dec-instreet-1",
+            intentId: "intent-instreet-1",
+            idempotencyKey: "instreet-list-1",
+        });
+        assert.equal(result.status, "terminal_failure", "instreet must return terminal_failure");
+        assert.equal(result.failureClass, "platform_unavailable", "failureClass must be platform_unavailable");
+    }
+    finally {
+        fs.rmSync(emptyWorkspace, { recursive: true, force: true });
+    }
+});
+test("T-CS.C.9-C: instreet execution does not return unknown_platform", async () => {
+    const emptyWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), "sn-instreet-"));
+    try {
+        const stateDb = createStateDatabase(":memory:");
+        const observabilityDb = createObservabilityDatabase(":memory:");
+        await seedCredential(stateDb);
+        const executor = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot: emptyWorkspace,
+        });
+        const result = await executor.executeEffect({
+            intent: "message.send",
+            platformId: "instreet",
+            payload: {},
+            decisionId: "dec-instreet-2",
+            intentId: "intent-instreet-2",
+            idempotencyKey: "instreet-send-1",
+        });
+        assert.equal(result.status, "terminal_failure");
+        const resultJson = JSON.stringify(result);
+        assert.ok(!resultJson.includes("unknown_platform"), "must not return unknown_platform");
+        assert.ok(resultJson.includes("platform_unavailable"), "must return platform_unavailable");
+    }
+    finally {
+        fs.rmSync(emptyWorkspace, { recursive: true, force: true });
+    }
+});

package/dist/tests/unit/connectors/manifest-v7-schema.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * T-CS.C.1 — CapabilityContractRegistry v7 扩展单元测试
+ *
+ * Verification types (05A / 05B):
+ * - 单元测试: v7 manifest schema 扩展；capabilityId 存在；严格 Zod 校验
+ *
+ * Dependencies: `src/connectors/base/manifest-v7.ts`
+ */
+export {};

package/dist/tests/unit/connectors/manifest-v7-schema.test.js

@@ -0,0 +1,165 @@
+/**
+ * T-CS.C.1 — CapabilityContractRegistry v7 扩展单元测试
+ *
+ * Verification types (05A / 05B):
+ * - 单元测试: v7 manifest schema 扩展；capabilityId 存在；严格 Zod 校验
+ *
+ * Dependencies: `src/connectors/base/manifest-v7.ts`
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { validateManifestV7, CapabilityContractRegistryV7, } from "../../../src/connectors/base/manifest-v7.js";
+function buildValidManifest() {
+    return {
+        platformId: "moltbook",
+        capabilities: [
+            {
+                capabilityId: "moltbook:feed.read",
+                intent: "feed.read",
+                description: "Read user feed",
+                probeConfig: {
+                    safeEndpoint: "https://api.moltbook.com/v1/feed",
+                    idempotencyClass: "read_only",
+                },
+                endpointMappings: {
+                    profilePath: "/api/v1/profile",
+                    claimPath: "/api/v1/claims",
+                    heartbeatPath: "/api/v1/heartbeat",
+                },
+            },
+        ],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+    };
+}
+describe("validateManifestV7 — schema strictness", () => {
+    it("accepts valid v7 manifest with probeConfig and endpointMappings", () => {
+        const result = validateManifestV7(buildValidManifest());
+        assert.strictEqual(result.ok, true);
+        assert.strictEqual(result.errors.length, 0);
+        assert.ok(result.manifest);
+        assert.strictEqual(result.manifest.capabilities[0].capabilityId, "moltbook:feed.read");
+    });
+    it("accepts manifest without optional probeConfig/endpointMappings", () => {
+        const manifest = buildValidManifest();
+        delete manifest.capabilities[0].probeConfig;
+        delete manifest.capabilities[0].endpointMappings;
+        const result = validateManifestV7(manifest);
+        assert.strictEqual(result.ok, true);
+        assert.strictEqual(result.errors.length, 0);
+    });
+    it("rejects manifest with empty platformId", () => {
+        const result = validateManifestV7({
+            ...buildValidManifest(),
+            platformId: "",
+        });
+        assert.strictEqual(result.ok, false);
+        assert.ok(result.errors.some((e) => e.includes("platformId")));
+    });
+    it("rejects manifest with empty capabilities array", () => {
+        const result = validateManifestV7({
+            ...buildValidManifest(),
+            capabilities: [],
+        });
+        assert.strictEqual(result.ok, false);
+        assert.ok(result.errors.some((e) => e.includes("capabilities")));
+    });
+    it("rejects manifest with invalid idempotencyClass", () => {
+        const manifest = buildValidManifest();
+        manifest.capabilities[0].probeConfig = {
+            safeEndpoint: "https://example.com",
+            idempotencyClass: "invalid",
+        };
+        const result = validateManifestV7(manifest);
+        assert.strictEqual(result.ok, false);
+        assert.ok(result.errors.some((e) => e.includes("idempotencyClass")));
+    });
+});
+describe("CapabilityContractRegistryV7 — register", () => {
+    it("registers valid manifest and returns ok", () => {
+        const registry = new CapabilityContractRegistryV7();
+        const result = registry.register(buildValidManifest());
+        assert.strictEqual(result.ok, true);
+        assert.strictEqual(result.errors.length, 0);
+    });
+    it("returns specific error when capabilityId is missing (DR-001)", () => {
+        const registry = new CapabilityContractRegistryV7();
+        const manifest = buildValidManifest();
+        manifest.capabilities[0].capabilityId = "";
+        const result = registry.register(manifest);
+        assert.strictEqual(result.ok, false);
+        assert.ok(result.errors.some((e) => e.includes("capabilityId missing") || e.includes("capabilityId")));
+    });
+    it("returns structured validation errors for invalid input", () => {
+        const registry = new CapabilityContractRegistryV7();
+        const result = registry.register({ invalid: true });
+        assert.strictEqual(result.ok, false);
+        assert.ok(result.errors.length > 0);
+    });
+    it("does not throw on invalid input", () => {
+        const registry = new CapabilityContractRegistryV7();
+        assert.doesNotThrow(() => {
+            registry.register({ invalid: true });
+        });
+    });
+});
+describe("CapabilityContractRegistryV7 — resolveCapability", () => {
+    it("resolves qualified capabilityId (platformId:capabilityId)", () => {
+        const registry = new CapabilityContractRegistryV7();
+        registry.register(buildValidManifest());
+        const resolved = registry.resolveCapability("moltbook:moltbook:feed.read");
+        assert.ok(resolved);
+        assert.strictEqual(resolved.capabilityId, "moltbook:feed.read");
+        assert.strictEqual(resolved.intent, "feed.read");
+    });
+    it("resolves unqualified capabilityId by search", () => {
+        const registry = new CapabilityContractRegistryV7();
+        registry.register(buildValidManifest());
+        const resolved = registry.resolveCapability("feed.read");
+        assert.ok(resolved);
+        assert.strictEqual(resolved.platformId, "moltbook");
+        assert.strictEqual(resolved.capabilityId, "moltbook:feed.read");
+    });
+    it("returns undefined for unknown capabilityId", () => {
+        const registry = new CapabilityContractRegistryV7();
+        registry.register(buildValidManifest());
+        const resolved = registry.resolveCapability("unknown:cap");
+        assert.strictEqual(resolved, undefined);
+    });
+    it("returns probeConfig from capability-level override", () => {
+        const registry = new CapabilityContractRegistryV7();
+        registry.register(buildValidManifest());
+        const config = registry.getProbeConfig("moltbook", "moltbook:feed.read");
+        assert.ok(config);
+        assert.strictEqual(config.safeEndpoint, "https://api.moltbook.com/v1/feed");
+        assert.strictEqual(config.idempotencyClass, "read_only");
+    });
+    it("returns endpointMappings from capability-level", () => {
+        const registry = new CapabilityContractRegistryV7();
+        registry.register(buildValidManifest());
+        const mappings = registry.getEndpointMappings("moltbook", "moltbook:feed.read");
+        assert.ok(mappings);
+        assert.strictEqual(mappings.profilePath, "/api/v1/profile");
+    });
+});
+describe("CapabilityContractRegistryV7 — hasCapability / listCapabilities", () => {
+    it("hasCapability returns true for registered capability", () => {
+        const registry = new CapabilityContractRegistryV7();
+        registry.register(buildValidManifest());
+        assert.strictEqual(registry.hasCapability("moltbook", "moltbook:feed.read"), true);
+    });
+    it("hasCapability returns false for unknown capability", () => {
+        const registry = new CapabilityContractRegistryV7();
+        registry.register(buildValidManifest());
+        assert.strictEqual(registry.hasCapability("moltbook", "unknown"), false);
+    });
+    it("listCapabilities returns all capabilities with flags", () => {
+        const registry = new CapabilityContractRegistryV7();
+        registry.register(buildValidManifest());
+        const list = registry.listCapabilities("moltbook");
+        assert.strictEqual(list.length, 1);
+        assert.strictEqual(list[0].capabilityId, "moltbook:feed.read");
+        assert.strictEqual(list[0].hasProbeConfig, true);
+        assert.strictEqual(list[0].hasEndpointMappings, true);
+    });
+});

package/dist/tests/unit/connectors/scriptable-node-runner.test.d.ts

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