@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/connectors/connector-executor-adapter-honest-failure.test.js

@@ -0,0 +1,311 @@
+/**
+ * Integration test: createConnectorExecutorAdapter honest failure paths.
+ *
+ * When credentials or base URLs are missing, the adapter returns terminal_failure
+ * instead of throwing, keeping the heartbeat loop stable.
+ */
+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 { createStateDatabase } from "../../../src/storage/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/index.js";
+import { createConnectorExecutorAdapter } from "../../../src/connectors/services/connector-executor-adapter.js";
+import { createCredentialVault } from "../../../src/storage/services/credential-vault.js";
+import { connectorInit } from "../../../src/cli/commands/connector-init.js";
+import { connectorBehaviorAdd } from "../../../src/cli/commands/connector-behavior.js";
+const ORIGINAL_KEY = process.env.SECOND_NATURE_ENCRYPTION_KEY;
+const ORIGINAL_MOLTBOOK_BASE_URL = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
+const ORIGINAL_AGENT_WORLD_BASE_URL = process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL;
+const ORIGINAL_AGENT_WORLD_USERNAME = process.env.SECOND_NATURE_AGENT_WORLD_USERNAME;
+const ORIGINAL_AGENT_WORLD_PROFILE_PATH_TEMPLATE = process.env.SECOND_NATURE_AGENT_WORLD_PROFILE_PATH_TEMPLATE;
+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_BASE_URL === undefined)
+        delete process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
+    else
+        process.env.SECOND_NATURE_MOLTBOOK_BASE_URL = ORIGINAL_MOLTBOOK_BASE_URL;
+    if (ORIGINAL_AGENT_WORLD_BASE_URL === undefined)
+        delete process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL;
+    else
+        process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL = ORIGINAL_AGENT_WORLD_BASE_URL;
+    if (ORIGINAL_AGENT_WORLD_USERNAME === undefined)
+        delete process.env.SECOND_NATURE_AGENT_WORLD_USERNAME;
+    else
+        process.env.SECOND_NATURE_AGENT_WORLD_USERNAME = ORIGINAL_AGENT_WORLD_USERNAME;
+    if (ORIGINAL_AGENT_WORLD_PROFILE_PATH_TEMPLATE === undefined) {
+        delete process.env.SECOND_NATURE_AGENT_WORLD_PROFILE_PATH_TEMPLATE;
+    }
+    else {
+        process.env.SECOND_NATURE_AGENT_WORLD_PROFILE_PATH_TEMPLATE =
+            ORIGINAL_AGENT_WORLD_PROFILE_PATH_TEMPLATE;
+    }
+});
+test("connector executor adapter loads workspace-defined behavior and fails closed at runner boundary", async () => {
+    const workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sn-dynamic-executor-"));
+    const stateDb = createStateDatabase();
+    const observabilityDb = createObservabilityDatabase();
+    try {
+        await connectorInit({ platformId: "github", workspaceRoot });
+        const add = await connectorBehaviorAdd({
+            platformId: "github",
+            behaviorId: "issue.search",
+            description: "Search issues before deciding whether to comment",
+            sourceRefs: ["quiet:proposal:github-issue-search"],
+            workspaceRoot,
+        });
+        assert.equal(add.ok, true);
+        const adapter = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot,
+        });
+        const result = await adapter.executeEffect({
+            platformId: "github",
+            intent: "issue.search",
+            payload: {},
+            decisionId: "dec-dynamic-1",
+            intentId: "intent-dynamic-1",
+            idempotencyKey: "idem-dynamic-1",
+        });
+        assert.equal(result.status, "terminal_failure");
+        assert.equal(result.failureClass, "configuration_missing");
+        assert.equal(result.metadata.platformId, "github");
+    }
+    finally {
+        stateDb.close();
+        observabilityDb.close();
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});
+test("connector executor adapter returns terminal_failure when credential missing", async () => {
+    const stateDb = createStateDatabase();
+    const observabilityDb = createObservabilityDatabase();
+    try {
+        const adapter = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+        });
+        const result = await adapter.executeEffect({
+            platformId: "moltbook",
+            intent: "feed.read",
+            payload: {},
+            decisionId: "dec-test-1",
+            intentId: "intent-test-1",
+            idempotencyKey: "idem-test-1",
+        });
+        assert.equal(result.status, "terminal_failure");
+        assert.ok(result.failureClass === "auth_failure", `Expected auth_failure, got: ${result.failureClass}`);
+        assert.equal(result.metadata.platformId, "moltbook");
+    }
+    finally {
+        stateDb.close();
+        observabilityDb.close();
+    }
+});
+test("connector executor adapter returns terminal_failure for evomap (not yet implemented)", async () => {
+    const stateDb = createStateDatabase();
+    const observabilityDb = createObservabilityDatabase();
+    try {
+        const adapter = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+        });
+        const result = await adapter.executeEffect({
+            platformId: "evomap",
+            intent: "work.discover",
+            payload: {},
+            decisionId: "dec-test-2",
+            intentId: "intent-test-2",
+            idempotencyKey: "idem-test-2",
+        });
+        assert.equal(result.status, "terminal_failure");
+        assert.ok(result.failureClass === "auth_failure" ||
+            result.failureClass === "unknown_platform_change", `Expected auth_failure or unknown_platform_change, got: ${result.failureClass}`);
+        assert.equal(result.metadata.platformId, "evomap");
+    }
+    finally {
+        stateDb.close();
+        observabilityDb.close();
+    }
+});
+test("connector executor adapter reads sql.js credential row and reaches Moltbook API", async () => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
+    process.env.SECOND_NATURE_MOLTBOOK_BASE_URL = "https://moltbook.test";
+    const originalFetch = globalThis.fetch;
+    let observedAuthorization;
+    globalThis.fetch = (async (_url, init) => {
+        const headers = init?.headers;
+        observedAuthorization = headers?.Authorization ?? headers?.authorization;
+        return new Response(JSON.stringify({ items: [{ id: "mb-1", title: "ok" }] }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+    });
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    try {
+        const vault = createCredentialVault(stateDb.db);
+        await vault.saveCredentialContext({
+            platformId: "moltbook",
+            credentialType: "api_key",
+            encryptedValue: "token-123",
+            status: "active",
+        });
+        const loaded = await vault.loadCredentialContext("moltbook");
+        assert.equal(loaded?.platformId, "moltbook");
+        assert.equal(loaded?.credentialType, "api_key");
+        assert.equal(loaded?.status, "active");
+        assert.equal(loaded?.encryptedValue, "token-123");
+        const adapter = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+        });
+        const result = await adapter.executeEffect({
+            platformId: "moltbook",
+            intent: "feed.read",
+            payload: { limit: 1 },
+            decisionId: "dec-test-success",
+            intentId: "intent-test-success",
+            idempotencyKey: "idem-test-success",
+        });
+        assert.equal(result.status, "success");
+        assert.equal(result.metadata.platformId, "moltbook");
+        assert.equal(observedAuthorization, "Bearer token-123");
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        stateDb.close();
+        observabilityDb.close();
+    }
+});
+test("agent-world feed.read uses real profile endpoint and vault credential", async () => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
+    process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL = "https://agent-world.test";
+    const originalFetch = globalThis.fetch;
+    let observedUrl = "";
+    let observedAuthorization;
+    globalThis.fetch = (async (url, init) => {
+        observedUrl = String(url);
+        const headers = init?.headers;
+        observedAuthorization = headers?.Authorization ?? headers?.authorization;
+        return new Response(JSON.stringify({ username: "nyx_ha" }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+    });
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    try {
+        const vault = createCredentialVault(stateDb.db);
+        await vault.saveCredentialContext({
+            platformId: "agent-world",
+            credentialType: "api_key",
+            encryptedValue: "agent-token-123",
+            status: "active",
+        });
+        const adapter = createConnectorExecutorAdapter({ stateDb, observabilityDb });
+        const result = await adapter.executeEffect({
+            platformId: "agent-world",
+            intent: "feed.read",
+            payload: {},
+            decisionId: "dec-agent-feed",
+            intentId: "intent-agent-feed",
+            idempotencyKey: "idem-agent-feed",
+        });
+        assert.equal(result.status, "success");
+        assert.equal(observedUrl, "https://agent-world.test/api/agents/profile/nyx_ha");
+        assert.equal(observedAuthorization, "Bearer agent-token-123");
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        stateDb.close();
+        observabilityDb.close();
+    }
+});
+test("agent-world work.discover allows Claw to choose target username", async () => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
+    process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL = "https://agent-world.test";
+    const originalFetch = globalThis.fetch;
+    let observedUrl = "";
+    globalThis.fetch = (async (url) => {
+        observedUrl = String(url);
+        return new Response(JSON.stringify({ username: "other_agent" }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+    });
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    try {
+        const vault = createCredentialVault(stateDb.db);
+        await vault.saveCredentialContext({
+            platformId: "agent-world",
+            credentialType: "api_key",
+            encryptedValue: "agent-token-456",
+            status: "active",
+        });
+        const adapter = createConnectorExecutorAdapter({ stateDb, observabilityDb });
+        const result = await adapter.executeEffect({
+            platformId: "agent-world",
+            intent: "work.discover",
+            payload: { targetUsername: "other agent" },
+            decisionId: "dec-agent-discover",
+            intentId: "intent-agent-discover",
+            idempotencyKey: "idem-agent-discover",
+        });
+        assert.equal(result.status, "success");
+        assert.equal(observedUrl, "https://agent-world.test/api/agents/profile/other%20agent");
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        stateDb.close();
+        observabilityDb.close();
+    }
+});
+test("agent-world profile path template is configurable", async () => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
+    process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL = "https://agent-world.test";
+    process.env.SECOND_NATURE_AGENT_WORLD_PROFILE_PATH_TEMPLATE =
+        "/api/custom/agents/{username}/profile";
+    const originalFetch = globalThis.fetch;
+    let observedUrl = "";
+    globalThis.fetch = (async (url) => {
+        observedUrl = String(url);
+        return new Response(JSON.stringify({ username: "custom_agent" }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+    });
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    try {
+        const vault = createCredentialVault(stateDb.db);
+        await vault.saveCredentialContext({
+            platformId: "agent-world",
+            credentialType: "api_key",
+            encryptedValue: "agent-token-789",
+            status: "active",
+        });
+        const adapter = createConnectorExecutorAdapter({ stateDb, observabilityDb });
+        const result = await adapter.executeEffect({
+            platformId: "agent-world",
+            intent: "feed.read",
+            payload: { username: "custom_agent" },
+            decisionId: "dec-agent-custom",
+            intentId: "intent-agent-custom",
+            idempotencyKey: "idem-agent-custom",
+        });
+        assert.equal(result.status, "success");
+        assert.equal(observedUrl, "https://agent-world.test/api/custom/agents/custom_agent/profile");
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        stateDb.close();
+        observabilityDb.close();
+    }
+});

package/dist/tests/integration/connectors/credential-optional-regression.test.d.ts

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

package/dist/tests/integration/connectors/credential-optional-regression.test.js

@@ -0,0 +1,117 @@
+/**
+ * Regression test for R-S9-01:
+ * When a workspace manifest declares credentials with `required: false`,
+ * route-planner must NOT throw `auth_failure` even if the credential is missing.
+ */
+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 { createStateDatabase } from "../../../src/storage/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/index.js";
+import { createConnectorExecutorAdapter } from "../../../src/connectors/services/connector-executor-adapter.js";
+test("optional credential (required: false) does not cause auth_failure when missing", async () => {
+    const workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sn-optional-cred-"));
+    const platformDir = path.join(workspaceRoot, ".second-nature", "connectors", "optional-platform");
+    fs.mkdirSync(platformDir, { recursive: true });
+    const manifestPath = path.join(platformDir, "manifest.yaml");
+    const manifestYaml = `schemaVersion: sn.connector.v1
+platformId: optional-platform
+displayName: Optional Platform
+family: custom
+capabilities:
+  - id: optional-platform.greet
+    description: Greet the platform
+runner:
+  kind: scriptable_node
+  entrypoint: "runner.mjs"
+credentials:
+  - type: api_key
+    required: false
+sourceRefPolicy:
+  minSourceRefs: 1
+  rejectInlineSensitivePayload: true
+trust:
+  status: declarative_trusted
+  reason: generated_by_regression_test
+`;
+    fs.writeFileSync(manifestPath, manifestYaml);
+    fs.writeFileSync(path.join(platformDir, "runner.mjs"), `export default async function handler() { return { success: true, data: { greeting: "hello" } }; }\n`, "utf-8");
+    const stateDb = createStateDatabase();
+    const observabilityDb = createObservabilityDatabase();
+    try {
+        const adapter = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot,
+        });
+        const result = await adapter.executeEffect({
+            platformId: "optional-platform",
+            intent: "optional-platform.greet",
+            payload: {},
+            decisionId: "dec-opt-1",
+            intentId: "intent-opt-1",
+            idempotencyKey: "idem-opt-1",
+        });
+        assert.notEqual(result.failureClass, "auth_failure", `Optional credential must not cause auth_failure, got: ${result.failureClass} (${result.status})`);
+        assert.notEqual(result.status, "terminal_failure", `Optional credential should not terminal-fail due to auth; got terminal_failure`);
+    }
+    finally {
+        stateDb.close();
+        observabilityDb.close();
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});
+test("required credential (default) still causes auth_failure when missing", async () => {
+    const workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sn-required-cred-"));
+    const platformDir = path.join(workspaceRoot, ".second-nature", "connectors", "required-platform");
+    fs.mkdirSync(platformDir, { recursive: true });
+    const manifestPath = path.join(platformDir, "manifest.yaml");
+    const manifestYaml = `schemaVersion: sn.connector.v1
+platformId: required-platform
+displayName: Required Platform
+family: custom
+capabilities:
+  - id: required-platform.greet
+    description: Greet the platform
+runner:
+  kind: declarative_http
+  entrypoint: ""
+  config:
+    baseUrl: http://localhost:99999
+credentials:
+  - type: api_key
+sourceRefPolicy:
+  minSourceRefs: 1
+  rejectInlineSensitivePayload: true
+trust:
+  status: declarative_trusted
+  reason: generated_by_regression_test
+`;
+    fs.writeFileSync(manifestPath, manifestYaml);
+    const stateDb = createStateDatabase();
+    const observabilityDb = createObservabilityDatabase();
+    try {
+        const adapter = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot,
+        });
+        const result = await adapter.executeEffect({
+            platformId: "required-platform",
+            intent: "required-platform.greet",
+            payload: {},
+            decisionId: "dec-req-1",
+            intentId: "intent-req-1",
+            idempotencyKey: "idem-req-1",
+        });
+        assert.equal(result.status, "terminal_failure");
+        assert.equal(result.failureClass, "auth_failure");
+    }
+    finally {
+        stateDb.close();
+        observabilityDb.close();
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});

package/dist/tests/integration/connectors/declarative-http-runner.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Wave 83 — Declarative HTTP Runner integration test
+ *
+ * Verifies that a workspace connector with runner.kind=declarative_http
+ * and runner.config.baseUrl is executed by the generic HTTP runner.
+ */
+export {};

package/dist/tests/integration/connectors/declarative-http-runner.test.js

@@ -0,0 +1,229 @@
+/**
+ * Wave 83 — Declarative HTTP Runner integration test
+ *
+ * Verifies that a workspace connector with runner.kind=declarative_http
+ * and runner.config.baseUrl is executed by the generic HTTP runner.
+ */
+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 http from "node:http";
+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;
+async function seedCredential(stateDb, platformId) {
+    const vault = createCredentialVault(stateDb.db);
+    await vault.saveCredentialContext({
+        platformId,
+        credentialType: "api_key",
+        encryptedValue: "test-token",
+        status: "active",
+    });
+}
+function createTestServer(responseData, onRequest) {
+    const server = http.createServer((req, res) => {
+        onRequest?.(req);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        const baseResponse = { path: req.url, method: req.method };
+        const merged = typeof responseData === "object" && responseData !== null
+            ? { ...baseResponse, ...responseData }
+            : baseResponse;
+        res.end(JSON.stringify(merged));
+    });
+    // Use random port
+    server.listen(0);
+    const address = server.address();
+    return {
+        server,
+        port: address.port,
+        url: `http://localhost:${address.port}`,
+    };
+}
+function tempWorkspaceWithConnector(manifestContent) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-http-test-"));
+    const connectorDir = path.join(dir, ".second-nature", "connectors", "my-custom-api");
+    fs.mkdirSync(connectorDir, { recursive: true });
+    fs.writeFileSync(path.join(connectorDir, "manifest.yaml"), manifestContent, "utf-8");
+    return dir;
+}
+test.beforeEach(() => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
+});
+test("W83: declarative_http connector with credentials: [] executes without Authorization header", async () => {
+    let authHeader;
+    const { server, url } = createTestServer({ ok: true }, (req) => {
+        authHeader = req.headers.authorization;
+    });
+    try {
+        const manifest = `schemaVersion: sn.connector.v1
+platformId: public-api
+displayName: Public API
+family: custom
+capabilities:
+  - id: feed.read
+    description: Read public feed
+runner:
+  kind: declarative_http
+  entrypoint: ""
+  config:
+    baseUrl: ${url}
+credentials: []
+sourceRefPolicy:
+  minSourceRefs: 1
+  rejectInlineSensitivePayload: true
+trust:
+  status: declarative_trusted
+`;
+        const workspaceRoot = tempWorkspaceWithConnector(manifest);
+        try {
+            const stateDb = createStateDatabase(":memory:");
+            const observabilityDb = createObservabilityDatabase(":memory:");
+            const executor = createConnectorExecutorAdapter({
+                stateDb,
+                observabilityDb,
+                workspaceRoot,
+            });
+            const result = await executor.executeEffect({
+                intent: "feed.read",
+                platformId: "public-api",
+                payload: {},
+                decisionId: "dec-w83-public",
+                intentId: "intent-w83-public",
+                idempotencyKey: "w83-public-api",
+            });
+            assert.equal(result.status, "success", `should succeed without credential: ${JSON.stringify(result)}`);
+            assert.equal(authHeader, undefined, "public connector must not send Authorization header");
+        }
+        finally {
+            fs.rmSync(workspaceRoot, { recursive: true, force: true });
+        }
+    }
+    finally {
+        server.close();
+    }
+});
+test.afterEach(() => {
+    if (ORIGINAL_KEY === undefined)
+        delete process.env.SECOND_NATURE_ENCRYPTION_KEY;
+    else
+        process.env.SECOND_NATURE_ENCRYPTION_KEY = ORIGINAL_KEY;
+});
+test("W83: declarative_http workspace connector executes via generic HTTP runner", async () => {
+    const { server, url } = createTestServer({ items: [{ id: "1", title: "Hello" }] });
+    try {
+        const manifest = `schemaVersion: sn.connector.v1
+platformId: my-custom-api
+displayName: My Custom API
+family: custom
+capabilities:
+  - id: feed.read
+    description: Read feed
+runner:
+  kind: declarative_http
+  entrypoint: ""
+  config:
+    baseUrl: ${url}
+credentials:
+  - type: api_key
+    required: true
+sourceRefPolicy:
+  minSourceRefs: 1
+  rejectInlineSensitivePayload: true
+trust:
+  status: declarative_trusted
+  reason: test_fixture
+`;
+        const workspaceRoot = tempWorkspaceWithConnector(manifest);
+        try {
+            const stateDb = createStateDatabase(":memory:");
+            const observabilityDb = createObservabilityDatabase(":memory:");
+            await seedCredential(stateDb, "my-custom-api");
+            const executor = createConnectorExecutorAdapter({
+                stateDb,
+                observabilityDb,
+                workspaceRoot,
+            });
+            const result = await executor.executeEffect({
+                intent: "feed.read",
+                platformId: "my-custom-api",
+                payload: {},
+                decisionId: "dec-w83-1",
+                intentId: "intent-w83-1",
+                idempotencyKey: "w83-custom-api-1",
+            });
+            assert.equal(result.status, "success", `should succeed: ${JSON.stringify(result)}`);
+            assert.ok(result.data, "result must have data");
+            const payload = result.data;
+            const data = payload.data;
+            assert.equal(data.path, "/feed/read", "should map capability to REST path");
+            assert.equal(data.method, "GET", "feed.read should use GET");
+            assert.ok(Array.isArray(data.items), "should return server response");
+        }
+        finally {
+            fs.rmSync(workspaceRoot, { recursive: true, force: true });
+        }
+    }
+    finally {
+        server.close();
+    }
+});
+test("W83: declarative_http POST capability uses POST method", async () => {
+    const { server, url } = createTestServer({ created: true });
+    try {
+        const manifest = `schemaVersion: sn.connector.v1
+platformId: my-post-api
+displayName: My Post API
+family: custom
+capabilities:
+  - id: post.publish
+    description: Publish post
+runner:
+  kind: declarative_http
+  entrypoint: ""
+  config:
+    baseUrl: ${url}
+credentials:
+  - type: api_key
+    required: true
+sourceRefPolicy:
+  minSourceRefs: 1
+  rejectInlineSensitivePayload: true
+trust:
+  status: declarative_trusted
+`;
+        const workspaceRoot = tempWorkspaceWithConnector(manifest);
+        try {
+            const stateDb = createStateDatabase(":memory:");
+            const observabilityDb = createObservabilityDatabase(":memory:");
+            await seedCredential(stateDb, "my-post-api");
+            const executor = createConnectorExecutorAdapter({
+                stateDb,
+                observabilityDb,
+                workspaceRoot,
+            });
+            const result = await executor.executeEffect({
+                intent: "post.publish",
+                platformId: "my-post-api",
+                payload: { content: "Hello world" },
+                decisionId: "dec-w83-2",
+                intentId: "intent-w83-2",
+                idempotencyKey: "w83-post-1",
+            });
+            assert.equal(result.status, "success");
+            const payload = result.data;
+            const data = payload.data;
+            assert.equal(data.path, "/post/publish");
+            assert.equal(data.method, "POST");
+        }
+        finally {
+            fs.rmSync(workspaceRoot, { recursive: true, force: true });
+        }
+    }
+    finally {
+        server.close();
+    }
+});

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

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