openclaw-adspirer 0.2.0 → 0.2.1

package/LICENSE

@@ -1,21 +1,8 @@
-MIT License
+Copyright (c) 2026 Adspirer, Inc. All rights reserved.
 
-Copyright (c) 2026 Adspirer
+This software is proprietary and confidential. Unauthorized copying, modification,
+distribution, or use of this software, via any medium, is strictly prohibited.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+This software is provided "as is" without warranty of any kind, express or implied.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+For licensing inquiries, contact: support@adspirer.com

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "openclaw-adspirer",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "OpenClaw plugin for Adspirer — manage Google, Meta, TikTok & LinkedIn ads via natural language",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
+  "files": [
+    "src/",
+    "types/",
+    "openclaw.plugin.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "scripts": {
     "check-types": "tsc --noEmit",
     "test": "ESBUILD_BINARY_PATH=./node_modules/@esbuild/linux-x64/bin/esbuild tsx --test tests/*.test.ts",

package/tests/auth.test.ts

@@ -1,75 +0,0 @@
-import { test, describe } from "node:test";
-import { strict as assert } from "node:assert";
-import { generateCodeVerifier, generateCodeChallenge, buildAuthUrl } from "../src/auth.ts";
-
-describe("generateCodeVerifier", () => {
-  test("length 43-128", () => {
-    const v = generateCodeVerifier();
-    assert.ok(v.length >= 43, `verifier too short: ${v.length}`);
-    assert.ok(v.length <= 128, `verifier too long: ${v.length}`);
-  });
-
-  test("base64url charset only", () => {
-    const v = generateCodeVerifier();
-    assert.ok(/^[A-Za-z0-9\-_]+$/.test(v), `invalid chars in verifier: ${v}`);
-  });
-
-  test("unique each time", () => {
-    const a = generateCodeVerifier();
-    const b = generateCodeVerifier();
-    assert.notEqual(a, b);
-  });
-});
-
-describe("generateCodeChallenge", () => {
-  test("produces base64url string", async () => {
-    const v = generateCodeVerifier();
-    const c = await generateCodeChallenge(v);
-    assert.ok(/^[A-Za-z0-9\-_]+$/.test(c));
-  });
-
-  test("known vector: dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk", async () => {
-    // RFC 7636 Appendix B test vector
-    const verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
-    const challenge = await generateCodeChallenge(verifier);
-    assert.equal(challenge, "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM");
-  });
-
-  test("deterministic", async () => {
-    const v = "test_verifier_string";
-    const a = await generateCodeChallenge(v);
-    const b = await generateCodeChallenge(v);
-    assert.equal(a, b);
-  });
-});
-
-describe("buildAuthUrl", () => {
-  test("contains all params using discovered authorize endpoint", () => {
-    const url = buildAuthUrl({
-      authorizeEndpoint: "https://mcp.adspirer.com/oauth/authorize",
-      clientId: "openclaw-abc123",
-      codeChallenge: "abc123",
-      redirectUri: "http://localhost:52847/callback",
-      scope: "ads:read ads:write accounts:read",
-      state: "state123",
-    });
-    assert.ok(url.includes("client_id=openclaw-abc123"), "missing client_id");
-    assert.ok(url.includes("redirect_uri=http%3A%2F%2Flocalhost%3A52847%2Fcallback"), "missing redirect_uri");
-    assert.ok(url.includes("response_type=code"), "missing response_type");
-    assert.ok(url.includes("code_challenge=abc123"), "missing code_challenge");
-    assert.ok(url.includes("code_challenge_method=S256"), "missing code_challenge_method");
-    assert.ok(url.includes("state=state123"), "missing state");
-  });
-
-  test("uses full authorize endpoint URL (not relative path)", () => {
-    const url = buildAuthUrl({
-      authorizeEndpoint: "https://auth.example.com/oauth/authorize",
-      clientId: "test-client",
-      codeChallenge: "challenge",
-      redirectUri: "http://localhost:3000/callback",
-      scope: "read",
-      state: "s",
-    });
-    assert.ok(url.startsWith("https://auth.example.com/oauth/authorize?"), `unexpected URL prefix: ${url}`);
-  });
-});

package/tests/client.test.ts

@@ -1,131 +0,0 @@
-import { test, describe, afterEach } from "node:test";
-import { strict as assert } from "node:assert";
-import { AdspirerMCPClient } from "../src/client.ts";
-import { parseConfig } from "../src/config.ts";
-import { installMockFetch, jsonResponse } from "./helpers/mock-fetch.ts";
-
-function makeClient(overrides: Record<string, unknown> = {}, fetchHandler?: (url: string | URL | Request, init?: RequestInit) => Promise<Response>) {
-  const config = parseConfig({
-    serverUrl: "https://test.example.com",
-    testMode: true,
-    ...overrides,
-  });
-  const logger = {
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  };
-  const client = new AdspirerMCPClient(
-    config,
-    async () => "test-token",
-    () => {},
-    async () => ({ accessToken: "new", refreshToken: "new", expiresIn: 3600, expiresAt: Date.now() + 3600000 }),
-    logger,
-  );
-  return client;
-}
-
-describe("AdspirerMCPClient", () => {
-  let restore: (() => void) | null = null;
-  afterEach(() => { if (restore) { restore(); restore = null; } });
-
-  test("callTool happy path", async () => {
-    const client = makeClient();
-    restore = installMockFetch(async () =>
-      jsonResponse({
-        jsonrpc: "2.0",
-        result: { content: [{ type: "text", text: "hello" }] },
-        id: "1",
-      }),
-    );
-    const result = await client.callTool("echo_test", { message: "hi" });
-    assert.equal(result.content[0].text, "hello");
-  });
-
-  test("callTool JSON-RPC error", async () => {
-    const client = makeClient();
-    restore = installMockFetch(async () =>
-      jsonResponse({
-        jsonrpc: "2.0",
-        error: { code: -32602, message: "bad param" },
-        id: "1",
-      }),
-    );
-    const result = await client.callTool("echo_test", {});
-    assert.ok(result.content[0].text.includes("bad param"));
-  });
-
-  test("callTool wraps non-content result", async () => {
-    const client = makeClient();
-    restore = installMockFetch(async () =>
-      jsonResponse({
-        jsonrpc: "2.0",
-        result: { data: "raw" },
-        id: "1",
-      }),
-    );
-    const result = await client.callTool("echo_test", {});
-    assert.ok(result.content[0].text.includes("raw"));
-  });
-
-  test("callTool 401 → refresh → retry (production mode)", async () => {
-    let callCount = 0;
-    const config = parseConfig({
-      serverUrl: "https://test.example.com",
-      testMode: false,
-      accessToken: "old-token",
-      refreshToken: "ref-token",
-      tokenExpiresAt: Date.now() + 3600000,
-    });
-    const logger = { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} };
-    let refreshCalled = false;
-    const client = new AdspirerMCPClient(
-      config,
-      async () => "old-token",
-      () => {},
-      async () => { refreshCalled = true; return { accessToken: "new", refreshToken: "new", expiresIn: 3600, expiresAt: Date.now() + 3600000 }; },
-      logger,
-    );
-
-    restore = installMockFetch(async () => {
-      callCount++;
-      if (callCount === 1) return new Response("Unauthorized", { status: 401 });
-      return jsonResponse({ jsonrpc: "2.0", result: { content: [{ type: "text", text: "ok" }] }, id: "1" });
-    });
-
-    const result = await client.callTool("echo_test", {});
-    assert.equal(refreshCalled, true);
-    assert.equal(result.content[0].text, "ok");
-  });
-
-  test("callTool 402 → upgrade message", async () => {
-    const client = makeClient({ testMode: false, accessToken: "tok", tokenExpiresAt: Date.now() + 3600000 });
-    restore = installMockFetch(async () => new Response("Payment Required", { status: 402 }));
-    const result = await client.callTool("premium_tool", {});
-    assert.ok(result.content[0].text.includes("Upgrade"));
-  });
-
-  test("listTools happy path", async () => {
-    const client = makeClient();
-    restore = installMockFetch(async () =>
-      jsonResponse({
-        jsonrpc: "2.0",
-        result: { tools: [{ name: "echo_test", description: "test", inputSchema: {} }] },
-        id: "1",
-      }),
-    );
-    const tools = await client.listTools();
-    assert.equal(tools.length, 1);
-    assert.equal(tools[0].name, "echo_test");
-  });
-
-  test("malformed response", async () => {
-    const client = makeClient();
-    restore = installMockFetch(async () =>
-      jsonResponse({ invalid: true }),
-    );
-    const result = await client.callTool("echo_test", {});
-    assert.ok(result.content[0].text.includes("Malformed"));
-  });
-});

package/tests/config.test.ts

@@ -1,115 +0,0 @@
-import { test, describe } from "node:test";
-import { strict as assert } from "node:assert";
-import { parseConfig, isAuthenticated, isTokenExpiringSoon, shouldRegisterTool } from "../src/config.ts";
-
-describe("parseConfig", () => {
-  test("empty config → defaults", () => {
-    const c = parseConfig({});
-    assert.equal(c.serverUrl, "https://mcp.adspirer.com");
-    assert.equal(c.requestTimeoutMs, 60000);
-    assert.equal(c.testMode, false);
-    assert.equal(c.enabledGroups.length, 6);
-    assert.equal(c.enabledTools.length, 0);
-    assert.equal(c.accessToken, undefined);
-  });
-
-  test("full config", () => {
-    const c = parseConfig({
-      serverUrl: "http://localhost:8000",
-      testMode: true,
-      testUserEmail: "test@test.com",
-      accessToken: "tok",
-      refreshToken: "ref",
-      tokenExpiresAt: 99999999999999,
-      defaultAccountId: "123",
-      enabledGroups: ["google_ads"],
-      enabledTools: ["echo_test"],
-      requestTimeoutMs: 120000,
-    });
-    assert.equal(c.serverUrl, "http://localhost:8000");
-    assert.equal(c.testMode, true);
-    assert.equal(c.testUserEmail, "test@test.com");
-    assert.equal(c.accessToken, "tok");
-    assert.equal(c.refreshToken, "ref");
-    assert.equal(c.enabledGroups.length, 1);
-    assert.equal(c.enabledTools.length, 1);
-    assert.equal(c.requestTimeoutMs, 120000);
-  });
-
-  test("partial config fills defaults", () => {
-    const c = parseConfig({ serverUrl: "https://custom.com" });
-    assert.equal(c.serverUrl, "https://custom.com");
-    assert.equal(c.requestTimeoutMs, 60000);
-    assert.equal(c.enabledGroups.length, 6);
-  });
-
-  test("null/undefined/non-object → defaults", () => {
-    for (const v of [null, undefined, "string", 42, []]) {
-      const c = parseConfig(v);
-      assert.equal(c.serverUrl, "https://mcp.adspirer.com");
-    }
-  });
-});
-
-describe("isAuthenticated", () => {
-  test("with valid token → true", () => {
-    const c = parseConfig({ accessToken: "tok", tokenExpiresAt: Date.now() + 3600000 });
-    assert.equal(isAuthenticated(c), true);
-  });
-
-  test("no token → false", () => {
-    assert.equal(isAuthenticated(parseConfig({})), false);
-  });
-
-  test("expired token → false", () => {
-    const c = parseConfig({ accessToken: "tok", tokenExpiresAt: Date.now() - 1000 });
-    assert.equal(isAuthenticated(c), false);
-  });
-
-  test("testMode → true regardless", () => {
-    const c = parseConfig({ testMode: true });
-    assert.equal(isAuthenticated(c), true);
-  });
-});
-
-describe("isTokenExpiringSoon", () => {
-  test("expiring within 5min → true", () => {
-    const c = parseConfig({ accessToken: "tok", tokenExpiresAt: Date.now() + 60000 });
-    assert.equal(isTokenExpiringSoon(c), true);
-  });
-
-  test("not expiring soon → false", () => {
-    const c = parseConfig({ accessToken: "tok", tokenExpiresAt: Date.now() + 600000 });
-    assert.equal(isTokenExpiringSoon(c), false);
-  });
-
-  test("testMode → false", () => {
-    const c = parseConfig({ testMode: true, tokenExpiresAt: Date.now() + 1000 });
-    assert.equal(isTokenExpiringSoon(c), false);
-  });
-});
-
-describe("shouldRegisterTool", () => {
-  test("system tool → always true", () => {
-    const c = parseConfig({ enabledGroups: ["google_ads"] });
-    assert.equal(shouldRegisterTool("get_usage_status", "system", c), true);
-    assert.equal(shouldRegisterTool("get_connections_status", "system", c), true);
-  });
-
-  test("group filter works", () => {
-    const c = parseConfig({ enabledGroups: ["google_ads"] });
-    assert.equal(shouldRegisterTool("get_campaign_performance", "google_ads", c), true);
-    assert.equal(shouldRegisterTool("pause_meta_campaign", "meta_ads", c), false);
-  });
-
-  test("enabledTools override", () => {
-    const c = parseConfig({ enabledTools: ["pause_meta_campaign"] });
-    assert.equal(shouldRegisterTool("pause_meta_campaign", "meta_ads", c), true);
-    assert.equal(shouldRegisterTool("get_campaign_performance", "google_ads", c), false);
-  });
-
-  test("default → all-on", () => {
-    const c = parseConfig({});
-    assert.equal(shouldRegisterTool("pause_meta_campaign", "meta_ads", c), true);
-  });
-});

package/tests/errors.test.ts

@@ -1,33 +0,0 @@
-import { test, describe } from "node:test";
-import { strict as assert } from "node:assert";
-import { mapHTTPError, mapJSONRPCError, createErrorResult, isRetryableError } from "../src/errors.ts";
-
-describe("mapHTTPError", () => {
-  test("401", () => assert.ok(mapHTTPError(401).includes("login")));
-  test("402", () => assert.ok(mapHTTPError(402).includes("Upgrade")));
-  test("403", () => assert.ok(mapHTTPError(403).includes("Access denied")));
-  test("429", () => assert.ok(mapHTTPError(429).includes("Rate limit")));
-  test("500", () => assert.ok(mapHTTPError(500).includes("service error")));
-});
-
-describe("mapJSONRPCError", () => {
-  test("-32601", () => assert.ok(mapJSONRPCError({ code: -32601, message: "" }).includes("not found")));
-  test("-32602", () => assert.ok(mapJSONRPCError({ code: -32602, message: "bad param" }).includes("bad param")));
-});
-
-describe("createErrorResult", () => {
-  test("wraps in content format", () => {
-    const r = createErrorResult("oops");
-    assert.equal(r.content.length, 1);
-    assert.equal(r.content[0].type, "text");
-    assert.ok(r.content[0].text.includes("oops"));
-  });
-});
-
-describe("isRetryableError", () => {
-  test("401 → true", () => assert.equal(isRetryableError(401), true));
-  test("429 → true", () => assert.equal(isRetryableError(429), true));
-  test("503 → true", () => assert.equal(isRetryableError(503), true));
-  test("500 → false", () => assert.equal(isRetryableError(500), false));
-  test("200 → false", () => assert.equal(isRetryableError(200), false));
-});

package/tests/helpers/mock-fetch.ts

@@ -1,12 +0,0 @@
-export function jsonResponse(body: unknown, status = 200, headers: Record<string, string> = {}): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json", ...headers },
-  });
-}
-
-export function installMockFetch(handler: (url: string | URL | Request, init?: RequestInit) => Promise<Response>): () => void {
-  const original = globalThis.fetch;
-  globalThis.fetch = handler as typeof fetch;
-  return () => { globalThis.fetch = original; };
-}

package/tests/tool-groups.test.ts

@@ -1,41 +0,0 @@
-import { test, describe } from "node:test";
-import { strict as assert } from "node:assert";
-import {
-  ALL_TOOLS, GOOGLE_ADS_TOOLS, META_ADS_TOOLS, TIKTOK_ADS_TOOLS,
-  LINKEDIN_ADS_TOOLS, MANUS_TOOLS, SYSTEM_TOOLS,
-  getGroupForTool, getToolsForGroups,
-} from "../src/tool-groups.ts";
-
-describe("tool counts", () => {
-  test("ALL_TOOLS = 104 (with 1 duplicate)", () => assert.equal(ALL_TOOLS.length, 104));
-  test("Google Ads = 40", () => assert.equal(GOOGLE_ADS_TOOLS.length, 40));
-  test("Meta Ads = 20", () => assert.equal(META_ADS_TOOLS.length, 20));
-  test("TikTok Ads = 4", () => assert.equal(TIKTOK_ADS_TOOLS.length, 4));
-  test("LinkedIn Ads = 28", () => assert.equal(LINKEDIN_ADS_TOOLS.length, 28));
-  test("Manus = 8", () => assert.equal(MANUS_TOOLS.length, 8));
-  test("System = 4", () => assert.equal(SYSTEM_TOOLS.length, 4));
-
-  test("ALL_TOOLS has 104 entries (get_usage_status in google_ads and system)", () => {
-    assert.equal(ALL_TOOLS.length, 104);
-    const unique = new Set(ALL_TOOLS);
-    assert.equal(unique.size, 103); // 103 unique tools
-  });
-});
-
-describe("getGroupForTool", () => {
-  test("known google tool", () => assert.equal(getGroupForTool("get_campaign_performance"), "google_ads"));
-  test("known meta tool", () => assert.equal(getGroupForTool("pause_meta_campaign"), "meta_ads"));
-  test("known system tool", () => assert.equal(getGroupForTool("switch_primary_account"), "system"));
-  test("unknown tool", () => assert.equal(getGroupForTool("nonexistent_tool"), null));
-});
-
-describe("getToolsForGroups", () => {
-  test("meta_ads + tiktok_ads = 24", () => {
-    const tools = getToolsForGroups(["meta_ads", "tiktok_ads"]);
-    assert.equal(tools.length, 24);
-  });
-
-  test("empty groups = 0", () => {
-    assert.equal(getToolsForGroups([]).length, 0);
-  });
-});

package/tests/tool-registry.test.ts

@@ -1,118 +0,0 @@
-import { test, describe, afterEach } from "node:test";
-import { strict as assert } from "node:assert";
-import { isWriteTool, fetchAndRegisterTools, registerStaticFallbacks, registerConnectTool, createToolExecutor } from "../src/tool-registry.ts";
-import { parseConfig } from "../src/config.ts";
-import { AdspirerMCPClient } from "../src/client.ts";
-import { installMockFetch, jsonResponse } from "./helpers/mock-fetch.ts";
-
-function makeMockApi() {
-  const registered: { name: string; opts?: any }[] = [];
-  return {
-    pluginConfig: {},
-    logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
-    registerTool: (tool: any, opts?: any) => { registered.push({ name: tool.name, opts }); },
-    registerCommand: () => {},
-    registerCli: () => {},
-    registerService: () => {},
-    on: () => {},
-    updateConfig: () => {},
-    _registered: registered,
-  };
-}
-
-function makeClient(config = parseConfig({ testMode: true, serverUrl: "https://test.example.com" })) {
-  return new AdspirerMCPClient(
-    config,
-    async () => "",
-    () => {},
-    async () => ({ accessToken: "", refreshToken: "", expiresIn: 3600, expiresAt: 0 }),
-    { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
-  );
-}
-
-describe("isWriteTool", () => {
-  test("create_ prefix → write", () => assert.equal(isWriteTool("create_search_campaign"), true));
-  test("update_ prefix → write", () => assert.equal(isWriteTool("update_campaign"), true));
-  test("pause_ prefix → write", () => assert.equal(isWriteTool("pause_campaign"), true));
-  test("get_ prefix → read", () => assert.equal(isWriteTool("get_campaign_performance"), false));
-  test("list_ prefix → read", () => assert.equal(isWriteTool("list_campaigns"), false));
-  test("analyze_ prefix → read", () => assert.equal(isWriteTool("analyze_wasted_spend"), false));
-  test("explicit write: switch_primary_account", () => assert.equal(isWriteTool("switch_primary_account"), true));
-  test("explicit write: infer_business_profile", () => assert.equal(isWriteTool("infer_business_profile"), true));
-  test("echo_test → read", () => assert.equal(isWriteTool("echo_test"), false));
-});
-
-describe("fetchAndRegisterTools", () => {
-  let restore: (() => void) | null = null;
-  afterEach(() => { if (restore) { restore(); restore = null; } });
-
-  test("registers tools from server", async () => {
-    const api = makeMockApi();
-    const config = parseConfig({ testMode: true, serverUrl: "https://test.example.com" });
-    const client = makeClient(config);
-
-    restore = installMockFetch(async () =>
-      jsonResponse({
-        jsonrpc: "2.0",
-        result: {
-          tools: [
-            { name: "echo_test", description: "test", inputSchema: {} },
-            { name: "create_search_campaign", description: "create", inputSchema: {} },
-          ],
-        },
-        id: "1",
-      }),
-    );
-
-    const count = await fetchAndRegisterTools(api as any, client, config);
-    assert.equal(count, 2);
-    assert.equal(api._registered.length, 2);
-    // echo_test is read, no confirmation needed
-    assert.equal(api._registered[0].opts, undefined);
-    // create_search_campaign is write, needs confirmation
-    assert.deepEqual(api._registered[1].opts, { needsConfirmation: true });
-  });
-
-  test("filters by enabledGroups", async () => {
-    const api = makeMockApi();
-    const config = parseConfig({ testMode: true, serverUrl: "https://test.example.com", enabledGroups: ["meta_ads"] });
-    const client = makeClient(config);
-
-    restore = installMockFetch(async () =>
-      jsonResponse({
-        jsonrpc: "2.0",
-        result: {
-          tools: [
-            { name: "get_campaign_performance", description: "google", inputSchema: {} },
-            { name: "get_meta_campaign_performance", description: "meta", inputSchema: {} },
-            { name: "get_usage_status", description: "system", inputSchema: {} }, // system always
-          ],
-        },
-        id: "1",
-      }),
-    );
-
-    const count = await fetchAndRegisterTools(api as any, client, config);
-    // get_campaign_performance filtered out (google_ads), meta + system stay
-    assert.equal(count, 2);
-  });
-});
-
-describe("registerStaticFallbacks", () => {
-  test("registers 6 fallback tools", () => {
-    const api = makeMockApi();
-    const config = parseConfig({ testMode: true });
-    const client = makeClient(config);
-    registerStaticFallbacks(api as any, client, config);
-    assert.equal(api._registered.length, 6);
-  });
-});
-
-describe("registerConnectTool", () => {
-  test("registers adspirer_connect", () => {
-    const api = makeMockApi();
-    registerConnectTool(api as any);
-    assert.equal(api._registered.length, 1);
-    assert.equal(api._registered[0].name, "adspirer_connect");
-  });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "rootDir": "."
-  },
-  "include": [
-    "src/**/*.ts",
-    "types/*.d.ts"
-  ],
-  "exclude": ["node_modules", "dist", "tests"]
-}

package/vitest.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: "node",
-    include: ["tests/**/*.test.ts"],
-  },
-});