@haaaiawd/second-nature 0.1.50 → 0.1.51

package/dist/tests/integration/connectors/evomap-secret-port.test.js

@@ -1,83 +0,0 @@
-/**
- * T-CS.C.10 — EvoMap secret port persistence integration test.
- *
- * Verifies that createEvoMapSecretPort (backed by credential vault)
- * can save and load node_secret across process boundaries (SQLite).
- */
-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 { createCredentialVault } from "../../../src/storage/services/credential-vault.js";
-import { createConnectorExecutorAdapter } from "../../../src/connectors/services/connector-executor-adapter.js";
-import { createObservabilityDatabase } from "../../../src/observability/db/index.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: "evomap",
-        credentialType: "api_key",
-        encryptedValue: "mock-api-key",
-        status: "active",
-    });
-}
-test("T-CS.C.10-G: evomap configuration_missing when base URL unset", async () => {
-    const emptyWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), "sn-evomap-"));
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot: emptyWorkspace,
-        });
-        delete process.env.SECOND_NATURE_EVOMAP_BASE_URL;
-        const result = await executor.executeEffect({
-            intent: "agent.heartbeat",
-            platformId: "evomap",
-            payload: {},
-            decisionId: "dec-evomap-1",
-            intentId: "intent-evomap-1",
-            idempotencyKey: "evomap-heartbeat-1",
-        });
-        assert.equal(result.status, "terminal_failure");
-        assert.equal(result.failureClass, "configuration_missing");
-    }
-    finally {
-        fs.rmSync(emptyWorkspace, { recursive: true, force: true });
-    }
-});
-test("T-CS.C.10-H: secret port saveNodeSecret / loadNodeSecret round-trip", async () => {
-    const stateDb = createStateDatabase(":memory:");
-    const vault = createCredentialVault(stateDb.db);
-    // Seed api_key for evomap (standard credential)
-    await vault.saveCredentialContext({
-        platformId: "evomap",
-        credentialType: "api_key",
-        encryptedValue: "mock-api-key",
-        status: "active",
-    });
-    // Import the secret port factory from the built dist (same module, built)
-    const { createEvoMapSecretPort } = await import("../../../src/connectors/services/connector-executor-adapter.js");
-    const secretPort = createEvoMapSecretPort(vault);
-    // Before save
-    const before = await secretPort.loadNodeSecret("evomap");
-    assert.equal(before, null, "node_secret must be null before save");
-    // Save
-    await secretPort.saveNodeSecret("evomap", "node-secret-42");
-    // Load
-    const after = await secretPort.loadNodeSecret("evomap");
-    assert.equal(after, "node-secret-42", "node_secret must round-trip through vault");
-});

package/dist/tests/integration/connectors/life-evidence-chain.test.d.ts

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

package/dist/tests/integration/connectors/life-evidence-chain.test.js

@@ -1,188 +0,0 @@
-/**
- * T-CS.C.8 — Life Evidence end-to-end chain integration test.
- *
- * Verifies the full path:
- *   moltbook mock runner → policy layer → ConnectorResult
- *   → mapLifeEvidence → appendLifeEvidence
- *   → life_evidence_index DB row + artifact file
- */
-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 { mapLifeEvidence } from "../../../src/connectors/base/map-life-evidence.js";
-import { appendLifeEvidence } from "../../../src/storage/life-evidence/append-life-evidence.js";
-import { lifeEvidenceIndex } from "../../../src/storage/db/schema/life-evidence-index.js";
-const ORIGINAL_KEY = process.env.SECOND_NATURE_ENCRYPTION_KEY;
-const ORIGINAL_MOLTBOOK_URL = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-function tempWorkspaceWithMock() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-le-chain-"));
-    const mockDir = path.join(dir, ".second-nature", "mock");
-    fs.mkdirSync(mockDir, { recursive: true });
-    fs.writeFileSync(path.join(mockDir, "moltbook-feed.json"), JSON.stringify({
-        items: [
-            { id: "chain-1", title: "Chain test item 1", content: "Hello chain" },
-            { id: "chain-2", title: "Chain test item 2", content: "World chain" },
-        ],
-    }), "utf-8");
-    return dir;
-}
-async function seedCredential(stateDb) {
-    const vault = createCredentialVault(stateDb.db);
-    await vault.saveCredentialContext({
-        platformId: "moltbook",
-        credentialType: "api_key",
-        encryptedValue: "mock-token",
-        status: "active",
-    });
-}
-test.beforeEach(() => {
-    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
-    delete process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-});
-test.afterEach(() => {
-    if (ORIGINAL_KEY === undefined)
-        delete process.env.SECOND_NATURE_ENCRYPTION_KEY;
-    else
-        process.env.SECOND_NATURE_ENCRYPTION_KEY = ORIGINAL_KEY;
-    if (ORIGINAL_MOLTBOOK_URL === undefined)
-        delete process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-    else
-        process.env.SECOND_NATURE_MOLTBOOK_BASE_URL = ORIGINAL_MOLTBOOK_URL;
-});
-test("T-CS.C.8-A: full chain produces life_evidence_index row and artifact", async () => {
-    const workspaceRoot = tempWorkspaceWithMock();
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        // DB before count
-        const beforeRows = await stateDb.db.select().from(lifeEvidenceIndex);
-        assert.equal(beforeRows.length, 0, "DB must be empty before test");
-        // 1. Execute through real executor + policy layer
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot,
-        });
-        const result = await executor.executeEffect({
-            intent: "feed.read",
-            platformId: "moltbook",
-            payload: {},
-            decisionId: "dec-chain-1",
-            intentId: "intent-chain-1",
-            idempotencyKey: "chain-feed-read-1",
-        });
-        assert.equal(result.status, "success", `execution should succeed: ${JSON.stringify(result)}`);
-        assert.ok(result.data, "result must contain data");
-        // 2. Map to life evidence candidate
-        const candidate = mapLifeEvidence({
-            platformId: "moltbook",
-            intent: "feed.read",
-            result,
-            observedAt: new Date().toISOString(),
-        });
-        assert.ok(candidate, "mapLifeEvidence must return non-null candidate");
-        assert.equal(candidate.evidenceType, "platform_browse");
-        assert.ok(candidate.sourceRefs.length > 0, "candidate must have sourceRefs");
-        // 3. Append to DB
-        const ack = await appendLifeEvidence(stateDb, workspaceRoot, candidate);
-        assert.ok(ack.evidenceId, "ack must contain evidenceId");
-        // 4. DB after count
-        const afterRows = await stateDb.db.select().from(lifeEvidenceIndex);
-        assert.equal(afterRows.length, 1, "DB must contain exactly 1 new evidence row");
-        assert.equal(afterRows[0].platformId, "moltbook");
-        assert.equal(afterRows[0].evidenceType, "platform_browse");
-        assert.equal(afterRows[0].producer, "connector-system");
-        assert.ok(afterRows[0].sourceRefsJson.includes("chain-1"), "sourceRefsJson must contain item ids");
-        // 5. Artifact file exists
-        const artifactPath = path.join(workspaceRoot, afterRows[0].artifactPath);
-        assert.ok(fs.existsSync(artifactPath), "artifact file must exist on disk");
-        const artifactContent = JSON.parse(fs.readFileSync(artifactPath, "utf-8"));
-        assert.equal(artifactContent.platformId, "moltbook");
-        assert.equal(artifactContent.evidenceType, "platform_browse");
-        assert.ok(artifactContent.sourceRefs.length > 0);
-    }
-    finally {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-});
-test("T-CS.C.8-B: policy-wrapped payload is penetrated by extractSourceRefs", async () => {
-    const workspaceRoot = tempWorkspaceWithMock();
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot,
-        });
-        const result = await executor.executeEffect({
-            intent: "feed.read",
-            platformId: "moltbook",
-            payload: {},
-            decisionId: "dec-chain-2",
-            intentId: "intent-chain-2",
-            idempotencyKey: "chain-feed-read-2",
-        });
-        assert.equal(result.status, "success");
-        // Verify policy-layer wrapping: data should be {capability, channel, data: {source, items}}
-        const payload = result.data;
-        assert.equal(payload.capability, "feed.read", "policy layer wraps capability");
-        assert.ok(payload.data && typeof payload.data === "object", "policy layer wraps nested data");
-        // mapLifeEvidence must still extract refs through nested data
-        const candidate = mapLifeEvidence({
-            platformId: "moltbook",
-            intent: "feed.read",
-            result,
-            observedAt: new Date().toISOString(),
-        });
-        assert.ok(candidate, "must extract refs through policy-wrapped nesting");
-        assert.equal(candidate.sourceRefs.length, 2, "must find both mock items");
-        assert.equal(candidate.sourceRefs[0].id, "chain-1");
-        assert.equal(candidate.sourceRefs[1].id, "chain-2");
-    }
-    finally {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-});
-test("T-CS.C.8-C: feed.read returns platform_browse evidenceType candidate", async () => {
-    const workspaceRoot = tempWorkspaceWithMock();
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot,
-        });
-        const result = await executor.executeEffect({
-            intent: "feed.read",
-            platformId: "moltbook",
-            payload: {},
-            decisionId: "dec-chain-3",
-            intentId: "intent-chain-3",
-            idempotencyKey: "chain-feed-read-3",
-        });
-        const candidate = mapLifeEvidence({
-            platformId: "moltbook",
-            intent: "feed.read",
-            result,
-            observedAt: new Date().toISOString(),
-        });
-        assert.ok(candidate);
-        assert.equal(candidate.evidenceType, "platform_browse");
-        assert.equal(candidate.producer, "connector-system");
-        assert.equal(candidate.sensitivity, "public");
-    }
-    finally {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-});

package/dist/tests/integration/connectors/moltbook-client.test.d.ts

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

package/dist/tests/integration/connectors/moltbook-client.test.js

@@ -1,274 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createServer } from "node:http";
-import { createMoltbookApiClient, MoltbookApiError } from "../../../src/connectors/social-community/moltbook/api-client.js";
-import { createMoltbookRunner } from "../../../src/connectors/social-community/moltbook/adapter.js";
-import { moltbookManifest } from "../../../src/connectors/social-community/moltbook/manifest.js";
-function createMoltbookStubServer() {
-    const requests = [];
-    const server = createServer(async (req, res) => {
-        const chunks = [];
-        for await (const chunk of req) {
-            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        }
-        const body = Buffer.concat(chunks).toString("utf-8");
-        requests.push({
-            method: req.method ?? "GET",
-            url: req.url ?? "/",
-            authorization: typeof req.headers.authorization === "string" ? req.headers.authorization : undefined,
-            body,
-        });
-        if (req.url?.startsWith("/api/v1/feed")) {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ posts: [{ id: "1", content: "stub-post" }] }));
-            return;
-        }
-        if (req.url === "/api/v1/posts" && req.method === "POST") {
-            res.writeHead(201, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ id: "post-1", status: "published" }));
-            return;
-        }
-        res.writeHead(404, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "not_found" }));
-    });
-    return {
-        requests,
-        async start() {
-            await new Promise((resolve, reject) => {
-                server.listen(0, "127.0.0.1", () => resolve());
-                server.once("error", reject);
-            });
-            const address = server.address();
-            return `http://127.0.0.1:${address.port}`;
-        },
-        async stop() {
-            await new Promise((resolve, reject) => {
-                server.close((error) => {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve();
-                });
-            });
-        },
-    };
-}
-test("T3.0.1 Moltbook manifest declares feed.read, post.publish, comment.reply capabilities", () => {
-    assert.equal(moltbookManifest.platformId, "moltbook");
-    assert.ok(moltbookManifest.supportedCapabilities.includes("feed.read"));
-    assert.ok(moltbookManifest.supportedCapabilities.includes("post.publish"));
-    assert.ok(moltbookManifest.supportedCapabilities.includes("comment.reply"));
-    assert.ok(moltbookManifest.channelPriority.includes("api_rest"));
-    assert.ok(moltbookManifest.credentialTypes.includes("api_key"));
-});
-test("T3.0.1 Moltbook adapter supports api_rest, skill, browser channels", () => {
-    const mockApiClient = {
-        readFeed: async () => ({ posts: [] }),
-        publishPost: async () => ({ id: "post-1" }),
-        replyComment: async () => ({ id: "comment-1" }),
-    };
-    const mockSkillRunner = {
-        run: async () => ({ result: "skill" }),
-    };
-    const runner = createMoltbookRunner({
-        apiClient: mockApiClient,
-        skillRunner: mockSkillRunner,
-    });
-    assert.ok(runner, "Moltbook runner should be created");
-    assert.ok(typeof runner.run === "function", "runner should have run method");
-});
-// ─── T3.1.1: Moltbook Minimal Client Tests ───────────────────────────────────
-test("T3.1.1 Moltbook API client creates with valid config", () => {
-    const client = createMoltbookApiClient({
-        baseUrl: "https://api.moltbook.com",
-        accessToken: "test-token",
-    });
-    assert.ok(client, "client should be created");
-    assert.ok(typeof client.readFeed === "function", "should have readFeed method");
-    assert.ok(typeof client.publishPost === "function", "should have publishPost method");
-    assert.ok(typeof client.replyComment === "function", "should have replyComment method");
-});
-test("T3.1.1 Moltbook API client readFeed uses real HTTP transport against near-real stub", async () => {
-    const stub = createMoltbookStubServer();
-    const baseUrl = await stub.start();
-    try {
-        const client = createMoltbookApiClient({
-            baseUrl,
-            accessToken: "test-token",
-        });
-        const result = await client.readFeed({ limit: 10, sort: "recent" });
-        assert.equal(stub.requests.length, 1);
-        assert.equal(stub.requests[0]?.method, "GET");
-        assert.ok(stub.requests[0]?.url.includes("/api/v1/feed"), "should call feed endpoint");
-        assert.ok(stub.requests[0]?.url.includes("limit=10"), "should include limit param");
-        assert.ok(stub.requests[0]?.url.includes("sort=recent"), "should include sort param");
-        assert.equal(stub.requests[0]?.authorization, "Bearer test-token");
-        assert.equal(result.posts[0]?.content, "stub-post");
-    }
-    finally {
-        await stub.stop();
-    }
-});
-test("T3.1.1 Moltbook API client publishPost uses real HTTP transport against near-real stub", async () => {
-    const stub = createMoltbookStubServer();
-    const baseUrl = await stub.start();
-    try {
-        const client = createMoltbookApiClient({
-            baseUrl,
-            accessToken: "test-token",
-        });
-        const result = await client.publishPost({
-            content: "Hello from Second Nature",
-            link: "https://example.com",
-        });
-        assert.equal(stub.requests.length, 1);
-        assert.equal(stub.requests[0]?.method, "POST");
-        assert.equal(stub.requests[0]?.url, "/api/v1/posts");
-        assert.equal(stub.requests[0]?.authorization, "Bearer test-token");
-        assert.ok(stub.requests[0]?.body.includes("Hello from Second Nature"), "should include content");
-        assert.ok(stub.requests[0]?.body.includes("https://example.com"), "should include link");
-        assert.equal(result.status, "published");
-    }
-    finally {
-        await stub.stop();
-    }
-});
-test("T3.1.1 Moltbook API client replyComment requires postId", async () => {
-    const client = createMoltbookApiClient({
-        baseUrl: "https://api.moltbook.com",
-        accessToken: "test-token",
-    });
-    try {
-        await client.replyComment({ content: "Nice post!" });
-        assert.fail("should throw when postId is missing");
-    }
-    catch (error) {
-        assert.ok(error instanceof MoltbookApiError, "should throw MoltbookApiError");
-        assert.equal(error.statusCode, 400);
-    }
-});
-test("T3.1.1 Moltbook API client handles API errors", async () => {
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = async () => ({
-        ok: false,
-        status: 401,
-        statusText: "Unauthorized",
-        json: async () => ({}),
-        text: async () => '{"error": "invalid_token"}',
-    });
-    try {
-        const client = createMoltbookApiClient({
-            baseUrl: "https://api.moltbook.com",
-            accessToken: "invalid-token",
-        });
-        await client.readFeed({});
-        assert.fail("should throw on API error");
-    }
-    catch (error) {
-        assert.ok(error instanceof MoltbookApiError, "should throw MoltbookApiError");
-        assert.equal(error.statusCode, 401);
-    }
-    finally {
-        globalThis.fetch = originalFetch;
-    }
-});
-test("T3.1.1 Moltbook runner executes feed.read via api_rest channel", async () => {
-    const mockApiClient = {
-        readFeed: async (payload) => ({
-            posts: [{ id: "1", content: "test post" }],
-        }),
-        publishPost: async () => ({}),
-        replyComment: async () => ({}),
-    };
-    const mockSkillRunner = {
-        run: async () => ({}),
-    };
-    const runner = createMoltbookRunner({
-        apiClient: mockApiClient,
-        skillRunner: mockSkillRunner,
-    });
-    const plan = {
-        platformId: "moltbook",
-        intent: "feed.read",
-        channel: "api_rest",
-        endpointMode: "rest_json",
-    };
-    const request = {
-        platformId: "moltbook",
-        intent: "feed.read",
-        payload: { limit: 10 },
-    };
-    const result = await runner.run(plan, request);
-    assert.equal(result.platformId, "moltbook");
-    assert.equal(result.channel, "api_rest");
-    assert.equal(result.success, true);
-    assert.ok(result.payload, "should have payload");
-    assert.equal(result.payload.capability, "feed.read");
-    assert.equal(result.payload.channel, "api_rest");
-});
-test("T3.1.1 Moltbook runner handles execution errors", async () => {
-    const mockApiClient = {
-        readFeed: async () => {
-            throw new Error("Network error");
-        },
-        publishPost: async () => ({}),
-        replyComment: async () => ({}),
-    };
-    const mockSkillRunner = {
-        run: async () => ({}),
-    };
-    const runner = createMoltbookRunner({
-        apiClient: mockApiClient,
-        skillRunner: mockSkillRunner,
-    });
-    const plan = {
-        platformId: "moltbook",
-        intent: "feed.read",
-        channel: "api_rest",
-        endpointMode: "rest_json",
-    };
-    const request = {
-        platformId: "moltbook",
-        intent: "feed.read",
-        payload: {},
-    };
-    const result = await runner.run(plan, request);
-    assert.equal(result.success, false);
-    assert.ok(result.error, "should have error");
-    assert.equal(result.platformId, "moltbook");
-    assert.equal(result.channel, "api_rest");
-});
-test("T3.1.1 Moltbook runner supports skill fallback channel", async () => {
-    const mockApiClient = {
-        readFeed: async () => ({}),
-        publishPost: async () => ({}),
-        replyComment: async () => ({}),
-    };
-    const mockSkillRunner = {
-        run: async (intent, payload) => ({
-            skillResult: true,
-            intent,
-            payload,
-        }),
-    };
-    const runner = createMoltbookRunner({
-        apiClient: mockApiClient,
-        skillRunner: mockSkillRunner,
-    });
-    const plan = {
-        platformId: "moltbook",
-        intent: "feed.read",
-        channel: "skill",
-        endpointMode: "skill_call",
-    };
-    const request = {
-        platformId: "moltbook",
-        intent: "feed.read",
-        payload: { limit: 5 },
-    };
-    const result = await runner.run(plan, request);
-    assert.equal(result.success, true);
-    assert.equal(result.channel, "skill");
-    assert.equal(result.degraded, true, "skill channel should be marked as degraded");
-    assert.ok(result.payload.data?.skillResult, "should have skill result");
-});

package/dist/tests/integration/connectors/moltbook-mock-runner.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Wave 81 — Moltbook Mock Runner integration tests
- *
- * Verifies that when SECOND_NATURE_MOLTBOOK_BASE_URL is unset,
- * the connector executor falls back to reading workspace mock data.
- */
-export {};

package/dist/tests/integration/connectors/moltbook-mock-runner.test.js

@@ -1,108 +0,0 @@
-/**
- * Wave 81 — Moltbook Mock Runner integration tests
- *
- * Verifies that when SECOND_NATURE_MOLTBOOK_BASE_URL is unset,
- * the connector executor falls back to reading workspace mock data.
- */
-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";
-const ORIGINAL_KEY = process.env.SECOND_NATURE_ENCRYPTION_KEY;
-const ORIGINAL_MOLTBOOK_URL = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-function tempWorkspaceWithMock() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-mock-test-"));
-    const mockDir = path.join(dir, ".second-nature", "mock");
-    fs.mkdirSync(mockDir, { recursive: true });
-    fs.writeFileSync(path.join(mockDir, "moltbook-feed.json"), JSON.stringify({
-        items: [
-            { id: "test-1", title: "Test item 1", content: "Hello from mock" },
-            { id: "test-2", title: "Test item 2", content: "Another mock item" },
-        ],
-    }), "utf-8");
-    return dir;
-}
-test.beforeEach(() => {
-    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
-    delete process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-});
-test.afterEach(() => {
-    if (ORIGINAL_KEY === undefined)
-        delete process.env.SECOND_NATURE_ENCRYPTION_KEY;
-    else
-        process.env.SECOND_NATURE_ENCRYPTION_KEY = ORIGINAL_KEY;
-    if (ORIGINAL_MOLTBOOK_URL === undefined)
-        delete process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-    else
-        process.env.SECOND_NATURE_MOLTBOOK_BASE_URL = ORIGINAL_MOLTBOOK_URL;
-});
-async function seedCredential(stateDb) {
-    const vault = createCredentialVault(stateDb.db);
-    await vault.saveCredentialContext({
-        platformId: "moltbook",
-        credentialType: "api_key",
-        encryptedValue: "mock-token",
-        status: "active",
-    });
-}
-test("W81: moltbook mock runner returns success when mock data exists", async () => {
-    const workspaceRoot = tempWorkspaceWithMock();
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot,
-        });
-        const result = await executor.executeEffect({
-            intent: "feed.read",
-            platformId: "moltbook",
-            payload: {},
-            decisionId: "dec-mock-1",
-            intentId: "intent-mock-1",
-            idempotencyKey: "mock-feed-read-1",
-        });
-        assert.equal(result.status, "success", `mock execution should succeed, got: ${JSON.stringify(result)}`);
-        assert.ok(result.data, "result must contain data");
-        const payload = result.data;
-        const data = payload.data;
-        assert.equal(data.source, "mock", "result must be tagged as mock source");
-        assert.ok(Array.isArray(data.items), "mock result must contain items array");
-        assert.equal(data.items.length, 2, "mock result must contain 2 items");
-    }
-    finally {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-});
-test("W81: moltbook mock runner returns terminal_failure when no mock data", async () => {
-    const emptyWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), "sn-empty-"));
-    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: "feed.read",
-            platformId: "moltbook",
-            payload: {},
-            decisionId: "dec-mock-2",
-            intentId: "intent-mock-2",
-            idempotencyKey: "mock-feed-read-2",
-        });
-        assert.equal(result.status, "terminal_failure", "should fail when no mock data and no base URL");
-    }
-    finally {
-        fs.rmSync(emptyWorkspace, { recursive: true, force: true });
-    }
-});

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

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