@haaaiawd/second-nature 0.1.50 → 0.1.51

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

@@ -1,38 +0,0 @@
-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

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

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

@@ -1,189 +0,0 @@
-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

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

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

@@ -1,249 +0,0 @@
-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

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