@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/integration/connectors/near-real-connector-smoke.test.js

@@ -0,0 +1,38 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { runNearRealConnectorSmoke } from "../../../src/connectors/near-real/near-real-connector-smoke.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { lifeEvidenceIndex } from "../../../src/storage/db/schema/life-evidence-index.js";
+import { executionAttempts } from "../../../src/observability/db/schema/index.js";
+import { eq } from "drizzle-orm";
+test("T3.3.1 near-real smoke — feed.read + work.discover evidence + connector execution attempts + task.claim dry sentinel", async () => {
+    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-near-real-"));
+    const state = createStateDatabase(":memory:");
+    const obs = createObservabilityDatabase(":memory:");
+    const report = await runNearRealConnectorSmoke({
+        state,
+        observabilityDb: obs,
+        workspaceRoot: ws,
+    });
+    assert.ok(report.feedReadEvidenceId);
+    assert.ok(report.workDiscoverEvidenceId);
+    assert.equal(report.taskClaimDryRunOk, true);
+    assert.ok(report.executionAttemptRowsForDecision >= 3);
+    const evidenceRows = await state.db.select().from(lifeEvidenceIndex);
+    const byPlatform = Object.fromEntries(evidenceRows.filter((r) => r.platformId).map((r) => [r.platformId, r]));
+    assert.equal(byPlatform.moltbook?.evidenceType, "platform_browse");
+    assert.equal(byPlatform.evomap?.evidenceType, "task_discovery");
+    const attempts = await obs.db.select().from(executionAttempts).where(eq(executionAttempts.decisionId, "dec-near-real-smoke"));
+    const caps = new Set(attempts.map((a) => a.capability));
+    assert.ok(caps.has("feed.read"));
+    assert.ok(caps.has("work.discover"));
+    assert.ok(caps.has("task.claim"));
+    assert.ok(attempts.some((a) => a.capability === "task.claim" && a.idempotencyKey === "idem-near-real-task-claim-smoke"));
+    state.close();
+    obs.close();
+    fs.rmSync(ws, { recursive: true, force: true });
+});

package/dist/tests/integration/connectors/platform-adapters.test.d.ts

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

package/dist/tests/integration/connectors/platform-adapters.test.js

@@ -0,0 +1,189 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { CapabilityContractRegistry, ChannelHealthStore, ConnectorRoutePlanner, createConnectorContractCore, } from "../../../src/connectors/base/index.js";
+import { createMoltbookRunner, moltbookManifest, MOLTBOOK_DOC_RISK } from "../../../src/connectors/social-community/moltbook/index.js";
+import { createInStreetRunner, instreetManifest } from "../../../src/connectors/social-community/instreet/index.js";
+import { createEvoMapRunner, evomapManifest } from "../../../src/connectors/agent-network/evomap/index.js";
+function makeStatePort(stateByPlatform) {
+    return {
+        async loadCredentialState(platformId) {
+            return {
+                platformId,
+                status: stateByPlatform[platformId] ?? "active",
+                credentialType: "api_key",
+                encryptedValue: "token-123",
+            };
+        },
+        async loadCooldownState() {
+            return { blocked: false };
+        },
+    };
+}
+test("moltbook adapter returns normalized result and keeps replaceable seam for skill/doc risk", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register(moltbookManifest);
+    const routePlanner = new ConnectorRoutePlanner(registry, makeStatePort({ moltbook: "active" }), new ChannelHealthStore());
+    const runner = createMoltbookRunner({
+        apiClient: {
+            async readFeed() {
+                return [{ id: "post-1" }];
+            },
+            async publishPost(payload) {
+                return { id: "new-post", text: payload.text };
+            },
+            async replyComment(payload) {
+                return { id: "reply-1", body: payload.body };
+            },
+        },
+        skillRunner: {
+            async run() {
+                return { via: "skill" };
+            },
+        },
+    });
+    const core = createConnectorContractCore({
+        manifestLoader: registry,
+        routePlanner,
+        executionRunner: runner,
+    });
+    const result = await core.executeCapability("feed.read", {
+        platformId: "moltbook",
+        intent: "feed.read",
+        payload: { topic: "ai" },
+    });
+    assert.equal(result.status, "success");
+    assert.equal(result.metadata.channel, "api_rest");
+    assert.ok(MOLTBOOK_DOC_RISK.key.includes("doc"));
+});
+test("instreet adapter uses canonical pending_verification recovery and api_rest boundary", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register(instreetManifest);
+    const routePlanner = new ConnectorRoutePlanner(registry, makeStatePort({ instreet: "pending_verification" }), new ChannelHealthStore());
+    let persistedStatus;
+    const runner = createInStreetRunner({
+        apiClient: {
+            async listNotifications(payload, apiKey) {
+                return { notifications: [], apiKeyUsed: apiKey, payload };
+            },
+            async sendMessage(payload, apiKey) {
+                return { sent: true, apiKeyUsed: apiKey, payload };
+            },
+            async replyComment(payload, apiKey) {
+                return { replied: true, apiKeyUsed: apiKey, payload };
+            },
+            async heartbeat(apiKey) {
+                return { ok: true, apiKeyUsed: apiKey };
+            },
+        },
+        skillRunner: {
+            async resumeVerification() {
+                return { status: "active", apiKey: "instreet-key" };
+            },
+            async run(intent, payload, context) {
+                return { via: "skill", intent, payload, apiKeyUsed: context.apiKey };
+            },
+        },
+        credentialPort: {
+            async loadCredentialState(platformId) {
+                return {
+                    platformId,
+                    status: "pending_verification",
+                    credentialType: "api_key",
+                    verificationCode: "code",
+                    challengeText: "challenge",
+                };
+            },
+            async persistVerificationOutcome(_platformId, outcome) {
+                persistedStatus = outcome.status;
+            },
+        },
+    });
+    const core = createConnectorContractCore({
+        manifestLoader: registry,
+        routePlanner,
+        executionRunner: runner,
+    });
+    const result = await core.executeCapability("notification.list", {
+        platformId: "instreet",
+        intent: "notification.list",
+        payload: {},
+    });
+    assert.equal(result.status, "success");
+    assert.equal(result.metadata.channel, "skill");
+    assert.equal(persistedStatus, "active");
+    assert.equal(result.data.data?.via, "skill");
+});
+test("evomap adapter enforces node_secret and separates a2a/api_rest bindings", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register(evomapManifest);
+    const routePlanner = new ConnectorRoutePlanner(registry, makeStatePort({ evomap: "active" }), new ChannelHealthStore());
+    let storedSecret = null;
+    const runner = createEvoMapRunner({
+        apiClient: {
+            async heartbeat(_payload, nodeSecret) {
+                return { heartbeat: "ok", nodeSecret };
+            },
+            async claimTask(_payload, nodeSecret) {
+                return { claimed: "t1", nodeSecret };
+            },
+        },
+        a2aClient: {
+            async helloOrRegister() {
+                return { your_node_id: "node-1", node_secret: "secret-1" };
+            },
+            async discoverWork(_payload, nodeSecret) {
+                return { tasks: ["t1"], nodeSecret };
+            },
+        },
+        secretPort: {
+            async loadNodeSecret() {
+                return storedSecret;
+            },
+            async saveNodeSecret(_platformId, nodeSecret) {
+                storedSecret = nodeSecret;
+            },
+        },
+    });
+    const core = createConnectorContractCore({
+        manifestLoader: registry,
+        routePlanner,
+        executionRunner: runner,
+    });
+    const reg = await core.executeCapability("agent.register", {
+        platformId: "evomap",
+        intent: "agent.register",
+        payload: {},
+        preferredChannel: "a2a",
+    });
+    assert.equal(reg.status, "success");
+    assert.equal(storedSecret, "secret-1");
+    const discover = await core.executeCapability("work.discover", {
+        platformId: "evomap",
+        intent: "work.discover",
+        payload: {},
+        preferredChannel: "a2a",
+    });
+    assert.equal(discover.status, "success");
+    assert.equal(discover.metadata.channel, "a2a");
+    const heartbeat = await core.executeCapability("agent.heartbeat", {
+        platformId: "evomap",
+        intent: "agent.heartbeat",
+        payload: {},
+    });
+    assert.equal(heartbeat.status, "success");
+    assert.equal(heartbeat.metadata.channel, "api_rest");
+    const claim = await core.executeCapability("task.claim", {
+        platformId: "evomap",
+        intent: "task.claim",
+        payload: {},
+    });
+    assert.equal(claim.status, "success");
+    const wrongChannel = await core.executeCapability("agent.heartbeat", {
+        platformId: "evomap",
+        intent: "agent.heartbeat",
+        payload: {},
+        preferredChannel: "a2a",
+    });
+    assert.equal(wrongChannel.status, "terminal_failure");
+    assert.equal(wrongChannel.failureClass, "protocol_mismatch");
+});

package/dist/tests/integration/connectors/policy-layer.test.d.ts

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

package/dist/tests/integration/connectors/policy-layer.test.js

@@ -0,0 +1,249 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createObservabilityDatabase, ExecutionTelemetry, obsSchema } from "../../../src/observability/index.js";
+import { CapabilityContractRegistry, ChannelHealthStore, ConnectorRoutePlanner, createConnectorPolicyLayer, } from "../../../src/connectors/base/index.js";
+function makeRouteContext(credentialState = "active") {
+    return {
+        async loadCredentialState(platformId) {
+            return {
+                platformId,
+                status: credentialState,
+                credentialType: "api_key",
+                encryptedValue: "api-key",
+            };
+        },
+        async loadCooldownState() {
+            return { blocked: false };
+        },
+    };
+}
+function makeRequest(intent, overrides = {}) {
+    return {
+        platformId: "instreet",
+        intent,
+        payload: {},
+        decisionId: "decision-1",
+        intentId: "intent-1",
+        ...overrides,
+    };
+}
+test("policy layer records telemetry and applies single-layer retry for InStreet 429 retry_after_seconds", async () => {
+    const db = createObservabilityDatabase(":memory:");
+    db.sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS execution_attempts (
+      id TEXT PRIMARY KEY,
+      trace_id TEXT NOT NULL,
+      decision_id TEXT NOT NULL,
+      intent_id TEXT NOT NULL,
+      platform_id TEXT NOT NULL,
+      capability TEXT NOT NULL,
+      channel TEXT NOT NULL,
+      status TEXT NOT NULL,
+      commit_state TEXT,
+      failure_class TEXT,
+      retry_policy TEXT,
+      idempotency_key TEXT,
+      started_at TEXT,
+      finished_at TEXT
+    );
+    CREATE TABLE IF NOT EXISTS redaction_manifest (
+      id TEXT PRIMARY KEY,
+      event_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      field_name TEXT NOT NULL,
+      action TEXT NOT NULL,
+      original_value_hash TEXT,
+      created_at TEXT NOT NULL
+    );
+  `);
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "instreet",
+        supportedCapabilities: ["notification.list"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+    });
+    const routePlanner = new ConnectorRoutePlanner(registry, makeRouteContext(), new ChannelHealthStore());
+    const telemetry = new ExecutionTelemetry(db);
+    let count = 0;
+    const policy = createConnectorPolicyLayer({
+        routePlanner,
+        telemetry,
+        retryPolicy: { maxRetries: 2, baseDelayMs: 1, maxDelayMs: 1, jitter: false },
+        executionRunner: {
+            async run(plan) {
+                count += 1;
+                if (count === 1) {
+                    return {
+                        platformId: "instreet",
+                        channel: plan.channel,
+                        latencyMs: 3,
+                        success: false,
+                        error: { status: 429, retryAfterSeconds: 0.001 },
+                    };
+                }
+                return {
+                    platformId: "instreet",
+                    channel: plan.channel,
+                    latencyMs: 2,
+                    success: true,
+                    payload: { ok: true },
+                };
+            },
+        },
+    });
+    const result = await policy.executeWithPolicy("notification.list", makeRequest("notification.list"));
+    assert.equal(result.status, "success");
+    assert.equal(count, 2);
+    const attempts = await db.db.select().from(obsSchema.executionAttempts);
+    assert.equal(attempts.length, 2);
+    assert.ok(attempts.some((row) => row.status === "failed"));
+    assert.ok(attempts.some((row) => row.status === "succeeded"));
+    assert.ok(attempts.every((row) => row.decisionId === "decision-1"));
+    assert.ok(attempts.every((row) => row.intentId === "intent-1"));
+    db.close();
+});
+test("policy layer classifies EvoMap protocol/auth errors without polluting base contract", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "evomap",
+        supportedCapabilities: ["task.claim"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["node_secret"],
+    });
+    const routePlanner = new ConnectorRoutePlanner(registry, makeRouteContext(), new ChannelHealthStore());
+    const errors = [
+        { code: "verification_required", detail: "node_secret_required", expected: "verification_required" },
+        { code: "protocol_mismatch", detail: "bundle_required", expected: "protocol_mismatch" },
+        { code: "protocol_mismatch", detail: "asset_id mismatch", expected: "protocol_mismatch" },
+    ];
+    for (const entry of errors) {
+        const policy = createConnectorPolicyLayer({
+            routePlanner,
+            retryPolicy: { maxRetries: 1, jitter: false, baseDelayMs: 1, maxDelayMs: 1 },
+            executionRunner: {
+                async run(plan) {
+                    return {
+                        platformId: "evomap",
+                        channel: plan.channel,
+                        latencyMs: 1,
+                        success: false,
+                        error: { code: entry.code, detail: entry.detail },
+                    };
+                },
+            },
+        });
+        const result = await policy.executeWithPolicy("task.claim", {
+            platformId: "evomap",
+            intent: "task.claim",
+            payload: {},
+            decisionId: "decision-evomap",
+            intentId: "intent-evomap",
+            idempotencyKey: `idem-evomap-claim:${entry.code}`,
+        });
+        assert.equal(result.status, "terminal_failure");
+        assert.equal(result.failureClass, entry.expected);
+    }
+});
+test("policy layer blocks degraded fallback when not allowed and marks degraded metadata", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "instreet",
+        supportedCapabilities: ["notification.list"],
+        channelPriority: ["skill"],
+        credentialTypes: ["api_key"],
+        degradedChannels: ["skill"],
+    });
+    const routePlanner = new ConnectorRoutePlanner(registry, makeRouteContext("pending_verification"), new ChannelHealthStore());
+    const blocked = createConnectorPolicyLayer({
+        routePlanner,
+        allowDegradedFallback: () => false,
+        executionRunner: {
+            async run() {
+                throw new Error("should_not_execute");
+            },
+        },
+    });
+    const blockedResult = await blocked.executeWithPolicy("notification.list", makeRequest("notification.list"));
+    assert.equal(blockedResult.status, "terminal_failure");
+    assert.equal(blockedResult.failureClass, "protocol_mismatch");
+    assert.equal(blockedResult.metadata.degraded, true);
+    const allowed = createConnectorPolicyLayer({
+        routePlanner,
+        allowDegradedFallback: () => true,
+        executionRunner: {
+            async run(plan) {
+                return {
+                    platformId: "instreet",
+                    channel: plan.channel,
+                    latencyMs: 1,
+                    degraded: true,
+                    success: true,
+                    payload: { ok: true },
+                };
+            },
+        },
+    });
+    const allowedResult = await allowed.executeWithPolicy("notification.list", makeRequest("notification.list"));
+    assert.equal(allowedResult.status, "success");
+    assert.equal(allowedResult.metadata.degraded, true);
+});
+test("policy layer applies cooldown block before execution", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "instreet",
+        supportedCapabilities: ["notification.list"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+    });
+    const routePlanner = new ConnectorRoutePlanner(registry, makeRouteContext(), new ChannelHealthStore());
+    const policy = createConnectorPolicyLayer({
+        routePlanner,
+        cooldownPort: {
+            async isBlocked() {
+                return { blocked: true, retryAfterMs: 5000 };
+            },
+            async markFailure() {
+                return;
+            },
+        },
+        executionRunner: {
+            async run() {
+                throw new Error("should_not_execute");
+            },
+        },
+    });
+    const result = await policy.executeWithPolicy("notification.list", makeRequest("notification.list"));
+    assert.equal(result.status, "terminal_failure");
+    assert.equal(result.failureClass, "cooldown_blocked");
+    assert.equal(result.retryAfterMs, 5000);
+});
+test("policy layer telemetry identity requires real decisionId and intentId", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "instreet",
+        supportedCapabilities: ["notification.list"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+    });
+    const routePlanner = new ConnectorRoutePlanner(registry, makeRouteContext(), new ChannelHealthStore());
+    const policy = createConnectorPolicyLayer({
+        routePlanner,
+        executionRunner: {
+            async run(plan) {
+                return {
+                    platformId: "instreet",
+                    channel: plan.channel,
+                    latencyMs: 1,
+                    success: true,
+                    payload: { ok: true },
+                };
+            },
+        },
+    });
+    await assert.rejects(() => policy.executeWithPolicy("notification.list", {
+        platformId: "instreet",
+        intent: "notification.list",
+        payload: {},
+    }), /connector_policy_missing_decision_or_intent_identity/);
+});

package/dist/tests/integration/connectors/scriptable-node-e2e.test.d.ts

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