@sweny-ai/core 0.1.40 → 0.1.42

package/dist/cli/credentials.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Read env vars into the flat credential map expected by buildAutoMcpServers
+ * and buildSkillMcpServers.
+ *
+ * Several env vars have two accepted spellings — the user-facing one
+ * (`NR_API_KEY`, `JIRA_BASE_URL`, `SENTRY_BASE_URL`, …) used in init.ts,
+ * config.ts, and docs, and the canonical one used by the MCP wiring layer
+ * (`NEW_RELIC_API_KEY`, `JIRA_URL`, `SENTRY_URL`, …). We accept either
+ * spelling and write the value under the canonical key the wiring functions
+ * look up. The user-facing spelling wins on conflict (it's what docs tell
+ * users to set).
+ */
+export declare function buildCredentialMap(env?: NodeJS.ProcessEnv): Record<string, string>;

package/dist/cli/credentials.js

@@ -0,0 +1,60 @@
+/**
+ * Read env vars into the flat credential map expected by buildAutoMcpServers
+ * and buildSkillMcpServers.
+ *
+ * Several env vars have two accepted spellings — the user-facing one
+ * (`NR_API_KEY`, `JIRA_BASE_URL`, `SENTRY_BASE_URL`, …) used in init.ts,
+ * config.ts, and docs, and the canonical one used by the MCP wiring layer
+ * (`NEW_RELIC_API_KEY`, `JIRA_URL`, `SENTRY_URL`, …). We accept either
+ * spelling and write the value under the canonical key the wiring functions
+ * look up. The user-facing spelling wins on conflict (it's what docs tell
+ * users to set).
+ */
+export function buildCredentialMap(env = process.env) {
+    const creds = {};
+    // [aliases…, canonical lookup key]
+    // Earlier aliases win on conflict — first non-empty match populates the canonical key.
+    const sources = [
+        [["GITHUB_TOKEN"], "GITHUB_TOKEN"],
+        [["GITLAB_TOKEN"], "GITLAB_TOKEN"],
+        [["GITLAB_URL"], "GITLAB_URL"],
+        [["LINEAR_API_KEY"], "LINEAR_API_KEY"],
+        // User-facing JIRA_BASE_URL → canonical JIRA_URL (the key the MCP layer reads).
+        [["JIRA_BASE_URL", "JIRA_URL"], "JIRA_URL"],
+        [["JIRA_EMAIL"], "JIRA_EMAIL"],
+        [["JIRA_API_TOKEN"], "JIRA_API_TOKEN"],
+        [["DD_API_KEY"], "DD_API_KEY"],
+        [["DD_APP_KEY"], "DD_APP_KEY"],
+        [["SENTRY_AUTH_TOKEN"], "SENTRY_AUTH_TOKEN"],
+        [["SENTRY_ORG"], "SENTRY_ORG"],
+        // User-facing SENTRY_BASE_URL → canonical SENTRY_URL.
+        [["SENTRY_BASE_URL", "SENTRY_URL"], "SENTRY_URL"],
+        // User-facing NR_* → canonical NEW_RELIC_*.
+        [["NR_API_KEY", "NEW_RELIC_API_KEY"], "NEW_RELIC_API_KEY"],
+        [["NR_REGION", "NEW_RELIC_REGION"], "NEW_RELIC_REGION"],
+        [["BETTERSTACK_API_TOKEN"], "BETTERSTACK_API_TOKEN"],
+        [["BETTERSTACK_TELEMETRY_TOKEN"], "BETTERSTACK_TELEMETRY_TOKEN"],
+        [["BETTERSTACK_UPTIME_TOKEN"], "BETTERSTACK_UPTIME_TOKEN"],
+        [["BETTERSTACK_SOURCE_ID"], "BETTERSTACK_SOURCE_ID"],
+        [["BETTERSTACK_TABLE_NAME"], "BETTERSTACK_TABLE_NAME"],
+        [["SLACK_BOT_TOKEN"], "SLACK_BOT_TOKEN"],
+        [["SLACK_TEAM_ID"], "SLACK_TEAM_ID"],
+        // mcp.ts accepts either NOTION_TOKEN or NOTION_API_KEY — populate both
+        // canonical keys so either env-var name reaches the wiring layer.
+        [["NOTION_TOKEN"], "NOTION_TOKEN"],
+        [["NOTION_API_KEY"], "NOTION_API_KEY"],
+        [["PAGERDUTY_API_TOKEN"], "PAGERDUTY_API_TOKEN"],
+        [["MONDAY_TOKEN"], "MONDAY_TOKEN"],
+        [["ASANA_ACCESS_TOKEN"], "ASANA_ACCESS_TOKEN"],
+    ];
+    for (const [aliases, canonical] of sources) {
+        for (const alias of aliases) {
+            const v = env[alias];
+            if (v) {
+                creds[canonical] = v;
+                break;
+            }
+        }
+    }
+    return creds;
+}

package/dist/cli/credentials.test.d.ts

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

package/dist/cli/credentials.test.js

@@ -0,0 +1,172 @@
+import { describe, it, expect } from "vitest";
+import { buildCredentialMap } from "./credentials.js";
+import { buildSkillMcpServers } from "../mcp.js";
+// ─────────────────────────────────────────────────────────────────────
+// Integration tests: env vars → buildCredentialMap → buildSkillMcpServers
+// ─────────────────────────────────────────────────────────────────────
+//
+// These tests catch env-var name drift between:
+//   - the user-facing env var name (what docs / init.ts / config.ts read)
+//   - the canonical key the MCP wiring functions look up
+//
+// Unit tests in mcp.test.ts inject the credentials map directly. That
+// validates each MCP wiring path but cannot catch a buildCredentialMap
+// that puts the value under the wrong key. THESE tests close that gap
+// by going through the real env-var → canonical-key translation.
+//
+// If a future contributor renames an env var and forgets to update both
+// sides, one of these will fail loudly.
+describe("buildCredentialMap ↔ buildSkillMcpServers integration", () => {
+    // ── New Relic: NR_API_KEY user-facing → NEW_RELIC_API_KEY canonical ──
+    it("user setting NR_API_KEY auto-wires the New Relic MCP", () => {
+        const creds = buildCredentialMap({ NR_API_KEY: "NRAK-abc" });
+        expect(creds.NEW_RELIC_API_KEY).toBe("NRAK-abc");
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["newrelic"]),
+            credentials: creds,
+        });
+        expect(mcps.newrelic).toBeDefined();
+        expect(mcps.newrelic?.url).toBe("https://mcp.newrelic.com/mcp/");
+    });
+    it("user setting NR_REGION=eu picks the EU New Relic endpoint", () => {
+        const creds = buildCredentialMap({ NR_API_KEY: "NRAK-abc", NR_REGION: "eu" });
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["newrelic"]),
+            credentials: creds,
+        });
+        expect(mcps.newrelic?.url).toBe("https://mcp.eu.newrelic.com/mcp/");
+    });
+    it("user setting NEW_RELIC_API_KEY (canonical name) also works", () => {
+        const creds = buildCredentialMap({ NEW_RELIC_API_KEY: "NRAK-xyz" });
+        expect(creds.NEW_RELIC_API_KEY).toBe("NRAK-xyz");
+    });
+    // ── Sentry: SENTRY_BASE_URL user-facing → SENTRY_URL canonical ──
+    it("user setting SENTRY_BASE_URL for self-hosted reaches the MCP layer", () => {
+        const creds = buildCredentialMap({
+            SENTRY_AUTH_TOKEN: "sntrys_abc",
+            SENTRY_BASE_URL: "https://sentry.acme.com",
+        });
+        expect(creds.SENTRY_URL).toBe("https://sentry.acme.com");
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["sentry"]),
+            credentials: creds,
+        });
+        expect(mcps.sentry).toBeDefined();
+        expect(mcps.sentry?.env?.SENTRY_HOST).toBe("sentry.acme.com");
+    });
+    it("user setting SENTRY_URL (canonical name) also reaches MCP layer", () => {
+        const creds = buildCredentialMap({
+            SENTRY_AUTH_TOKEN: "sntrys_abc",
+            SENTRY_URL: "https://sentry.acme.com",
+        });
+        expect(creds.SENTRY_URL).toBe("https://sentry.acme.com");
+    });
+    it("default sentry.io URL does not set SENTRY_HOST", () => {
+        const creds = buildCredentialMap({ SENTRY_AUTH_TOKEN: "sntrys_abc" });
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["sentry"]),
+            credentials: creds,
+        });
+        expect(mcps.sentry).toBeDefined();
+        expect(mcps.sentry?.env?.SENTRY_HOST).toBeUndefined();
+    });
+    // ── Jira: JIRA_BASE_URL user-facing → JIRA_URL canonical ──
+    it("user setting JIRA_BASE_URL auto-wires the Jira MCP", () => {
+        const creds = buildCredentialMap({
+            JIRA_BASE_URL: "https://acme.atlassian.net",
+            JIRA_EMAIL: "alice@acme.com",
+            JIRA_API_TOKEN: "tok_abc",
+        });
+        expect(creds.JIRA_URL).toBe("https://acme.atlassian.net");
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["jira"]),
+            credentials: creds,
+        });
+        expect(mcps.jira).toBeDefined();
+        expect(mcps.jira?.env?.JIRA_URL).toBe("https://acme.atlassian.net");
+    });
+    it("user setting JIRA_URL (canonical name) also auto-wires Jira", () => {
+        const creds = buildCredentialMap({
+            JIRA_URL: "https://acme.atlassian.net",
+            JIRA_EMAIL: "alice@acme.com",
+            JIRA_API_TOKEN: "tok_abc",
+        });
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["jira"]),
+            credentials: creds,
+        });
+        expect(mcps.jira).toBeDefined();
+    });
+    it("Jira MCP is NOT wired without all 3 creds", () => {
+        const creds = buildCredentialMap({
+            JIRA_BASE_URL: "https://acme.atlassian.net",
+            JIRA_EMAIL: "alice@acme.com",
+            // missing JIRA_API_TOKEN
+        });
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["jira"]),
+            credentials: creds,
+        });
+        expect(mcps.jira).toBeUndefined();
+    });
+    // ── Notion: both env-var spellings ──
+    it("user setting NOTION_API_KEY (official Notion name) auto-wires Notion MCP", () => {
+        const creds = buildCredentialMap({ NOTION_API_KEY: "secret_abc" });
+        expect(creds.NOTION_API_KEY).toBe("secret_abc");
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["notion"]),
+            credentials: creds,
+        });
+        expect(mcps.notion).toBeDefined();
+        expect(mcps.notion?.env?.NOTION_TOKEN).toBe("secret_abc");
+    });
+    it("user setting NOTION_TOKEN auto-wires Notion MCP", () => {
+        const creds = buildCredentialMap({ NOTION_TOKEN: "secret_xyz" });
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["notion"]),
+            credentials: creds,
+        });
+        expect(mcps.notion?.env?.NOTION_TOKEN).toBe("secret_xyz");
+    });
+    // ── BetterStack token fallbacks ──
+    it("user setting BETTERSTACK_API_TOKEN auto-wires BetterStack MCP", () => {
+        const creds = buildCredentialMap({ BETTERSTACK_API_TOKEN: "bs_abc" });
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["betterstack"]),
+            credentials: creds,
+        });
+        expect(mcps.betterstack).toBeDefined();
+        expect(mcps.betterstack?.headers?.Authorization).toBe("Bearer bs_abc");
+    });
+    it("user setting BETTERSTACK_TELEMETRY_TOKEN reaches the MCP layer", () => {
+        const creds = buildCredentialMap({ BETTERSTACK_TELEMETRY_TOKEN: "bs_tel_abc" });
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["betterstack"]),
+            credentials: creds,
+        });
+        expect(mcps.betterstack?.headers?.Authorization).toBe("Bearer bs_tel_abc");
+    });
+    // ── Happy-path: all the common providers at once ──
+    it("end-to-end: a typical SRE triage env wires every expected MCP", () => {
+        const creds = buildCredentialMap({
+            GITHUB_TOKEN: "ghp_abc",
+            LINEAR_API_KEY: "lin_abc",
+            DD_API_KEY: "dd_api",
+            DD_APP_KEY: "dd_app",
+            SLACK_BOT_TOKEN: "xoxb-abc",
+        });
+        const mcps = buildSkillMcpServers({
+            referencedSkills: new Set(["github", "linear", "datadog", "slack"]),
+            credentials: creds,
+        });
+        expect(Object.keys(mcps).sort()).toEqual(["datadog", "github", "linear", "slack"]);
+    });
+    it("returns empty creds for an empty env", () => {
+        expect(buildCredentialMap({})).toEqual({});
+    });
+    it("ignores empty-string env values (treats them as unset)", () => {
+        const creds = buildCredentialMap({ GITHUB_TOKEN: "", LINEAR_API_KEY: "lin_abc" });
+        expect(creds.GITHUB_TOKEN).toBeUndefined();
+        expect(creds.LINEAR_API_KEY).toBe("lin_abc");
+    });
+});

package/dist/cli/init.js

@@ -238,7 +238,7 @@ export function buildActionWorkflow(credentials, cronExpression) {
     lines.push("    runs-on: ubuntu-latest");
     lines.push("    steps:");
     lines.push("      - uses: actions/checkout@v4");
-    lines.push("      - uses: swenyai/sweny@v4");
+    lines.push("      - uses: swenyai/sweny@v5");
     lines.push("        with:");
     lines.push("          workflow: triage");
     if (secretCreds.length > 0) {

package/dist/cli/init.test.js

@@ -271,7 +271,7 @@ describe("buildActionWorkflow", () => {
         expect(workflow).toContain('cron: "0 8 * * 1"');
         expect(workflow).toContain("workflow_dispatch:");
         expect(workflow).toContain("actions/checkout@v4");
-        expect(workflow).toContain("swenyai/sweny@v4");
+        expect(workflow).toContain("swenyai/sweny@v5");
     });
     it("generates a workflow with daily cron", () => {
         const creds = collectCredentials({

package/dist/cli/main.js

@@ -21,6 +21,7 @@ import { toMermaid, toMermaidBlock } from "../mermaid.js";
 import { DagRenderer } from "./renderer.js";
 import * as readline from "node:readline";
 import { loadDotenv, loadConfigFile } from "./config-file.js";
+import { buildCredentialMap } from "./credentials.js";
 import { runInit } from "./init.js";
 import { runE2eInit, runE2eRun } from "./e2e.js";
 import { registerTriageCommand, registerImplementCommand, parseCliInputs, validateInputs, validateWarnings, } from "./config.js";
@@ -100,45 +101,8 @@ program
 });
 registerSetupCommand(program);
 // ── Credential map builder ──────────────────────────────────────────
-/**
- * Read env vars into the flat credential map expected by buildAutoMcpServers.
- */
-function buildCredentialMap() {
-    const creds = {};
-    const env = process.env;
-    const keys = [
-        "GITHUB_TOKEN",
-        "GITLAB_TOKEN",
-        "GITLAB_URL",
-        "LINEAR_API_KEY",
-        "JIRA_URL",
-        "JIRA_EMAIL",
-        "JIRA_API_TOKEN",
-        "DD_API_KEY",
-        "DD_APP_KEY",
-        "SENTRY_AUTH_TOKEN",
-        "SENTRY_ORG",
-        "SENTRY_URL",
-        "NR_API_KEY",
-        "NR_REGION",
-        "BETTERSTACK_API_TOKEN",
-        "BETTERSTACK_TELEMETRY_TOKEN",
-        "BETTERSTACK_UPTIME_TOKEN",
-        "BETTERSTACK_SOURCE_ID",
-        "BETTERSTACK_TABLE_NAME",
-        "SLACK_BOT_TOKEN",
-        "SLACK_TEAM_ID",
-        "NOTION_TOKEN",
-        "PAGERDUTY_API_TOKEN",
-        "MONDAY_TOKEN",
-        "ASANA_ACCESS_TOKEN",
-    ];
-    for (const k of keys) {
-        if (env[k])
-            creds[k] = env[k];
-    }
-    return creds;
-}
+// buildCredentialMap lives in ./credentials.ts so tests can import it
+// without triggering main.ts's top-level program.parse() side effect.
 /**
  * Build the McpAutoConfig from CLI config for buildAutoMcpServers.
  */

package/dist/mcp.test.js

@@ -495,4 +495,174 @@ describe("buildSkillMcpServers", () => {
         expect(result["datadog"]).toBeDefined();
         expect(result["slack"]).toBeDefined();
     });
+    // ── GitLab ─────────────────────────────────────────────────────────
+    it("wires gitlab MCP when referenced and GITLAB_TOKEN present", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["gitlab"]),
+            credentials: { GITLAB_TOKEN: "glpat_abc" },
+        });
+        expect(result["gitlab"]).toEqual({
+            type: "stdio",
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-gitlab@latest"],
+            env: { GITLAB_PERSONAL_ACCESS_TOKEN: "glpat_abc" },
+        });
+    });
+    it("wires gitlab MCP with self-hosted GITLAB_API_URL", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["gitlab"]),
+            credentials: { GITLAB_TOKEN: "glpat_abc", GITLAB_URL: "https://gitlab.example.com" },
+        });
+        expect(result["gitlab"]?.env).toEqual({
+            GITLAB_PERSONAL_ACCESS_TOKEN: "glpat_abc",
+            GITLAB_API_URL: "https://gitlab.example.com/api/v4",
+        });
+    });
+    // ── Jira ───────────────────────────────────────────────────────────
+    it("wires jira MCP when all 3 creds present", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["jira"]),
+            credentials: {
+                JIRA_URL: "https://acme.atlassian.net",
+                JIRA_EMAIL: "alice@acme.com",
+                JIRA_API_TOKEN: "tok_abc",
+            },
+        });
+        expect(result["jira"]).toEqual({
+            type: "stdio",
+            command: "npx",
+            args: ["-y", "@sooperset/mcp-atlassian@latest"],
+            env: {
+                JIRA_URL: "https://acme.atlassian.net",
+                JIRA_EMAIL: "alice@acme.com",
+                JIRA_API_TOKEN: "tok_abc",
+            },
+        });
+    });
+    it("does NOT wire jira MCP when JIRA_EMAIL is missing", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["jira"]),
+            credentials: { JIRA_URL: "https://acme.atlassian.net", JIRA_API_TOKEN: "tok_abc" },
+        });
+        expect(result["jira"]).toBeUndefined();
+    });
+    // ── New Relic ──────────────────────────────────────────────────────
+    it("wires newrelic MCP with US (default) endpoint", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["newrelic"]),
+            credentials: { NEW_RELIC_API_KEY: "NRAK-abc" },
+        });
+        expect(result["newrelic"]).toEqual({
+            type: "http",
+            url: "https://mcp.newrelic.com/mcp/",
+            headers: { "Api-Key": "NRAK-abc" },
+        });
+    });
+    it("wires newrelic MCP with EU endpoint when NEW_RELIC_REGION=eu", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["newrelic"]),
+            credentials: { NEW_RELIC_API_KEY: "NRAK-abc", NEW_RELIC_REGION: "eu" },
+        });
+        expect(result["newrelic"]?.url).toBe("https://mcp.eu.newrelic.com/mcp/");
+    });
+    it("does NOT wire newrelic MCP without NEW_RELIC_API_KEY", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["newrelic"]),
+            credentials: { NEW_RELIC_REGION: "eu" },
+        });
+        expect(result["newrelic"]).toBeUndefined();
+    });
+    // ── Notion (both env-var spellings) ────────────────────────────────
+    it("wires notion MCP with NOTION_TOKEN", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["notion"]),
+            credentials: { NOTION_TOKEN: "secret_abc" },
+        });
+        expect(result["notion"]).toEqual({
+            type: "stdio",
+            command: "npx",
+            args: ["-y", "@notionhq/notion-mcp-server@latest"],
+            env: { NOTION_TOKEN: "secret_abc" },
+        });
+    });
+    it("wires notion MCP with NOTION_API_KEY fallback", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["notion"]),
+            credentials: { NOTION_API_KEY: "secret_xyz" },
+        });
+        expect(result["notion"]?.env?.NOTION_TOKEN).toBe("secret_xyz");
+    });
+    it("prefers NOTION_TOKEN over NOTION_API_KEY when both set", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["notion"]),
+            credentials: { NOTION_TOKEN: "primary", NOTION_API_KEY: "fallback" },
+        });
+        expect(result["notion"]?.env?.NOTION_TOKEN).toBe("primary");
+    });
+    // ── PagerDuty / Monday / Asana ─────────────────────────────────────
+    it("wires pagerduty MCP with Token-token auth scheme", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["pagerduty"]),
+            credentials: { PAGERDUTY_API_TOKEN: "pd_abc" },
+        });
+        expect(result["pagerduty"]).toEqual({
+            type: "http",
+            url: "https://mcp.pagerduty.com/mcp",
+            headers: { Authorization: "Token token=pd_abc" },
+        });
+    });
+    it("wires monday MCP", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["monday"]),
+            credentials: { MONDAY_TOKEN: "mon_abc" },
+        });
+        expect(result["monday"]).toEqual({
+            type: "stdio",
+            command: "npx",
+            args: ["-y", "@mondaydotcomorg/monday-api-mcp@latest"],
+            env: { MONDAY_TOKEN: "mon_abc" },
+        });
+    });
+    it("wires asana MCP", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["asana"]),
+            credentials: { ASANA_ACCESS_TOKEN: "asana_abc" },
+        });
+        expect(result["asana"]).toEqual({
+            type: "stdio",
+            command: "npx",
+            args: ["-y", "asana-mcp@latest"],
+            env: { ASANA_ACCESS_TOKEN: "asana_abc" },
+        });
+    });
+    // ── BetterStack token fallback ─────────────────────────────────────
+    it("wires betterstack with BETTERSTACK_TELEMETRY_TOKEN fallback", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["betterstack"]),
+            credentials: { BETTERSTACK_TELEMETRY_TOKEN: "bs_tel_abc" },
+        });
+        expect(result["betterstack"]).toEqual({
+            type: "http",
+            url: "https://mcp.betterstack.com",
+            headers: { Authorization: "Bearer bs_tel_abc" },
+        });
+    });
+    it("wires betterstack with BETTERSTACK_UPTIME_TOKEN fallback", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["betterstack"]),
+            credentials: { BETTERSTACK_UPTIME_TOKEN: "bs_up_abc" },
+        });
+        expect(result["betterstack"]?.headers?.Authorization).toBe("Bearer bs_up_abc");
+    });
+    it("prefers BETTERSTACK_API_TOKEN over telemetry/uptime fallbacks", () => {
+        const result = buildSkillMcpServers({
+            referencedSkills: new Set(["betterstack"]),
+            credentials: {
+                BETTERSTACK_API_TOKEN: "primary",
+                BETTERSTACK_TELEMETRY_TOKEN: "fallback1",
+                BETTERSTACK_UPTIME_TOKEN: "fallback2",
+            },
+        });
+        expect(result["betterstack"]?.headers?.Authorization).toBe("Bearer primary");
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"