@ashlr/stack-core 0.1.1 → 0.3.0

package/src/__tests__/mcp-mirror.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mergeMcpEntry, removeMcpEntry } from "../mcp-writer.ts";
+
+const tmp = () => mkdtempSync(join(tmpdir(), "stack-mirror-"));
+const readJson = (p: string) => JSON.parse(readFileSync(p, "utf-8"));
+
+describe("mcp-writer client mirroring", () => {
+  test("does not create client dirs that are absent", async () => {
+    const cwd = tmp();
+    await mergeMcpEntry({ name: "s", type: "stdio", command: "npx" }, cwd);
+    expect(existsSync(join(cwd, ".mcp.json"))).toBe(true);
+    expect(existsSync(join(cwd, ".cursor"))).toBe(false);
+    expect(existsSync(join(cwd, ".gemini"))).toBe(false);
+  });
+
+  test("mirrors into .cursor/mcp.json and .gemini/settings.json when dirs exist", async () => {
+    const cwd = tmp();
+    mkdirSync(join(cwd, ".cursor"));
+    mkdirSync(join(cwd, ".gemini"));
+    writeFileSync(
+      join(cwd, ".gemini", "settings.json"),
+      JSON.stringify({ theme: "dark", mcpServers: { other: { command: "o" } } }),
+    );
+    await mergeMcpEntry(
+      { name: "s", type: "stdio", command: "npx", args: ["-y", "x"], env: { K: "v" } },
+      cwd,
+    );
+    const g = readJson(join(cwd, ".gemini", "settings.json"));
+    expect(g.theme).toBe("dark");
+    expect(g.mcpServers.other.command).toBe("o");
+    expect(g.mcpServers.s).toEqual({ command: "npx", args: ["-y", "x"], env: { K: "v" } });
+    expect(readJson(join(cwd, ".cursor", "mcp.json")).mcpServers.s.command).toBe("npx");
+    // idempotent
+    await mergeMcpEntry(
+      { name: "s", type: "stdio", command: "npx", args: ["-y", "x"], env: { K: "v" } },
+      cwd,
+    );
+    expect(Object.keys(readJson(join(cwd, ".gemini", "settings.json")).mcpServers).sort()).toEqual([
+      "other",
+      "s",
+    ]);
+  });
+
+  test("gemini uses httpUrl for http and url for sse, with no type field", async () => {
+    const cwd = tmp();
+    mkdirSync(join(cwd, ".gemini"));
+    await mergeMcpEntry({ name: "h", type: "http", url: "https://a.example/mcp" }, cwd);
+    await mergeMcpEntry({ name: "e", type: "sse", url: "https://b.example/sse" }, cwd);
+    const m = readJson(join(cwd, ".gemini", "settings.json")).mcpServers;
+    expect(m.h).toEqual({ httpUrl: "https://a.example/mcp" });
+    expect(m.e).toEqual({ url: "https://b.example/sse" });
+    expect(readJson(join(cwd, ".mcp.json")).mcpServers.h.type).toBe("http");
+  });
+
+  test("a malformed sibling config is left untouched and does not fail the write", async () => {
+    const cwd = tmp();
+    mkdirSync(join(cwd, ".gemini"));
+    writeFileSync(join(cwd, ".gemini", "settings.json"), "{not json");
+    await mergeMcpEntry({ name: "s", type: "stdio", command: "npx" }, cwd);
+    expect(readFileSync(join(cwd, ".gemini", "settings.json"), "utf-8")).toBe("{not json");
+    expect(readJson(join(cwd, ".mcp.json")).mcpServers.s.command).toBe("npx");
+  });
+
+  test("removeMcpEntry removes from mirrors and keeps other entries", async () => {
+    const cwd = tmp();
+    mkdirSync(join(cwd, ".cursor"));
+    mkdirSync(join(cwd, ".gemini"));
+    await mergeMcpEntry({ name: "a", type: "stdio", command: "x" }, cwd);
+    await mergeMcpEntry({ name: "b", type: "stdio", command: "y" }, cwd);
+    await removeMcpEntry("a", cwd);
+    for (const p of [
+      join(cwd, ".mcp.json"),
+      join(cwd, ".cursor", "mcp.json"),
+      join(cwd, ".gemini", "settings.json"),
+    ]) {
+      const m = readJson(p).mcpServers;
+      expect(m.a).toBeUndefined();
+      expect(m.b.command).toBe("y");
+    }
+  });
+
+  test("a user's own same-name entry is neither overwritten nor deleted", async () => {
+    // Cursor and Gemini configs are user-owned. A hand-written "github" entry
+    // must survive `stack add github` and its rollback or `stack remove`.
+    const cwd = tmp();
+    mkdirSync(join(cwd, ".cursor"));
+    mkdirSync(join(cwd, ".gemini"));
+    const mine = { command: "my-github-mcp", env: { TOKEN: "${env:GH}" } };
+    for (const p of [join(cwd, ".cursor", "mcp.json"), join(cwd, ".gemini", "settings.json")]) {
+      writeFileSync(p, JSON.stringify({ mcpServers: { github: mine } }));
+    }
+    await mergeMcpEntry({ name: "github", type: "stdio", command: "npx", args: ["-y", "gh"] }, cwd);
+    expect(readJson(join(cwd, ".mcp.json")).mcpServers.github.command).toBe("npx");
+    for (const p of [join(cwd, ".cursor", "mcp.json"), join(cwd, ".gemini", "settings.json")]) {
+      expect(readJson(p).mcpServers.github).toEqual(mine);
+    }
+    await removeMcpEntry("github", cwd);
+    expect(readJson(join(cwd, ".mcp.json")).mcpServers.github).toBeUndefined();
+    for (const p of [join(cwd, ".cursor", "mcp.json"), join(cwd, ".gemini", "settings.json")]) {
+      expect(readJson(p).mcpServers.github).toEqual(mine);
+    }
+  });
+
+  test("an entry Stack mirrored earlier is updated when the provider entry changes", async () => {
+    const cwd = tmp();
+    mkdirSync(join(cwd, ".cursor"));
+    await mergeMcpEntry({ name: "s", type: "stdio", command: "npx", args: ["v1"] }, cwd);
+    await mergeMcpEntry({ name: "s", type: "stdio", command: "npx", args: ["v2"] }, cwd);
+    expect(readJson(join(cwd, ".cursor", "mcp.json")).mcpServers.s.args).toEqual(["v2"]);
+    await removeMcpEntry("s", cwd);
+    expect(readJson(join(cwd, ".cursor", "mcp.json")).mcpServers.s).toBeUndefined();
+  });
+});

package/src/__tests__/neon-provider.test.ts

@@ -1,8 +1,16 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import neon from "../providers/neon.ts";
+import { readFileSync, writeFileSync } from "node:fs";
+import { emptyConfig, readConfig, writeConfig } from "../config.ts";
+import { addService } from "../pipeline.ts";
 import type { ProviderContext } from "../providers/_base.ts";
+import { providers } from "../providers/index.ts";
+import neon from "../providers/neon.ts";
 import { type Harness, readVault, setupFakePhantom } from "./_harness.ts";
 
+const inertPreconnect: typeof fetch.preconnect = () => {
+  throw new Error("Unexpected fetch preconnect in inert fixture.");
+};
+
 describe("neon provider (mocked fetch)", () => {
   let h: Harness;
   let realFetch: typeof fetch;
@@ -14,6 +22,7 @@ describe("neon provider (mocked fetch)", () => {
 
   afterEach(() => {
     globalThis.fetch = realFetch;
+    Reflect.deleteProperty(providers, "neonrollbackfixture");
     h.cleanup();
   });
 
@@ -51,9 +60,60 @@ describe("neon provider (mocked fetch)", () => {
     expect(materialized.secrets.NEON_API_KEY).toBe("neon_fake");
     expect(materialized.secrets.DATABASE_URL).toBe(connectionUri);
 
-    // Provision stores a project-scoped copy so other providers can't stomp it.
+    // Provision never writes the vault before pipeline rollback owns the resource.
     const vault = await readVault(h.dir);
-    expect(vault[`NEON_DATABASE_URL_${projectId}`]).toBe(connectionUri);
+    expect(vault[`NEON_DATABASE_URL_${projectId}`]).toBeUndefined();
+    // DATABASE_URL is written once, by the pipeline from materialize(): Phantom
+    // never replaces a stored name, so provision must not claim it first.
+    expect(vault.DATABASE_URL).toBeUndefined();
+  });
+
+  test("fresh URI storage failure reaches rollback after the created resource is returned", async () => {
+    const projectId = "proj_rollback";
+    await writeConfig(emptyConfig(), h.dir);
+    writeFileSync(h.vaultPath, JSON.stringify({ DATABASE_URL: "synthetic-existing" }));
+    const before = readFileSync(`${h.dir}/.stack.toml`, "utf8");
+    const calls = { created: 0, freshURI: 0, deleted: 0 };
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const u = String(url);
+      const method = init?.method ?? "GET";
+      if (u.endsWith("/projects") && method === "POST") {
+        calls.created++;
+        return new Response(
+          JSON.stringify({
+            project: { id: projectId, name: "inert", region_id: "fixture" },
+            connection_uris: [{ connection_uri: "synthetic-provision-uri" }],
+          }),
+          { status: 201 },
+        );
+      }
+      if (u.endsWith(`/projects/${projectId}/connection_uri`) && method === "GET") {
+        calls.freshURI++;
+        return new Response(JSON.stringify({ uri: "synthetic-fresh-uri" }), { status: 200 });
+      }
+      if (u.endsWith(`/projects/${projectId}`) && method === "DELETE") {
+        calls.deleted++;
+        return new Response("", { status: 200 });
+      }
+      throw new Error(`unexpected inert ${method} route`);
+    }) as unknown as typeof fetch;
+    providers.neonrollbackfixture = async () => ({
+      ...neon,
+      name: "neonrollbackfixture",
+      async login() {
+        return { token: "synthetic-key", identity: {} };
+      },
+    });
+    await expect(
+      addService({ providerName: "neonrollbackfixture", cwd: h.dir, interactive: false }),
+    ).rejects.toMatchObject({ code: "ADD_SERVICE_ROLLED_BACK" });
+    expect(calls).toEqual({ created: 1, freshURI: 1, deleted: 1 });
+    expect(readFileSync(`${h.dir}/.stack.toml`, "utf8")).toBe(before);
+    expect((await readConfig(h.dir)).services.neonrollbackfixture).toBeUndefined();
+    const vault = await readVault(h.dir);
+    expect(vault.DATABASE_URL).toBe("synthetic-existing");
+    expect(vault[`NEON_DATABASE_URL_${projectId}`]).toBeUndefined();
+    expect(h.callsTo("add").map((call) => call.args[0])).toEqual(["NEON_API_KEY", "DATABASE_URL"]);
   });
 
   test("healthcheck returns error when the project 404s", async () => {
@@ -76,4 +136,77 @@ describe("neon provider (mocked fetch)", () => {
     });
     expect(status.kind).toBe("error");
   });
+  test.each([204, 404])(
+    "DELETE %i is accepted exactly once without reading response bodies",
+    async (status) => {
+      let deletes = 0;
+      globalThis.fetch = Object.assign(
+        async (_url: unknown, init?: RequestInit) => {
+          expect(init?.method).toBe("DELETE");
+          deletes++;
+          return new Response(null, { status });
+        },
+        { preconnect: inertPreconnect },
+      );
+      await expect(
+        neon.deprovision!(
+          { cwd: h.dir, interactive: false, log() {} },
+          { token: "synthetic-key" },
+          "inert-project",
+        ),
+      ).resolves.toBeUndefined();
+      expect(deletes).toBe(1);
+    },
+  );
+
+  test.each([403, 500])(
+    "DELETE %i refuses unconfirmed teardown without exposing response contents",
+    async (status) => {
+      let deletes = 0;
+      globalThis.fetch = Object.assign(
+        async (_url: unknown, init?: RequestInit) => {
+          expect(init?.method).toBe("DELETE");
+          deletes++;
+          return new Response("synthetic-private-response-must-not-surface", { status });
+        },
+        { preconnect: inertPreconnect },
+      );
+      const error = await neon.deprovision!(
+        { cwd: h.dir, interactive: false, log() {} },
+        { token: "synthetic-key" },
+        "inert-project",
+      ).catch((err: Error) => err);
+      expect(error).toMatchObject({ code: "NEON_DELETE_FAILED" });
+      expect((error as Error).message).toContain(String(status));
+      expect((error as Error).message).not.toContain("synthetic-private-response-must-not-surface");
+      expect(deletes).toBe(1);
+    },
+  );
+
+  test("network failure refuses teardown with a fixed safe error and no raw transport output", async () => {
+    let deletes = 0;
+    const logs: string[] = [];
+    globalThis.fetch = Object.assign(
+      async () => {
+        deletes++;
+        throw new Error("synthetic-sensitive-transport-detail");
+      },
+      { preconnect: inertPreconnect },
+    );
+    const error = await neon.deprovision!(
+      {
+        cwd: h.dir,
+        interactive: false,
+        log(event) {
+          logs.push(event.msg);
+        },
+      },
+      { token: "synthetic-key" },
+      "inert-project",
+    ).catch((err: Error) => err);
+    expect(error).toMatchObject({ code: "NEON_DELETE_UNCONFIRMED" });
+    expect((error as Error).message).not.toContain("synthetic-sensitive-transport-detail");
+    expect(logs.join(" ")).not.toContain("synthetic-sensitive-transport-detail");
+    expect(deletes).toBe(1);
+  });
 });