Skip to content

armgit / mso

Public Imported from GitHub
0

Browser-based graphical shell and control plane for a Linux server you own — real terminal, file manager, live metrics and BYOK AI in one mobile-first workspace. Next.js 16 · React 19 · node-pty · Tailwind v4 · shadcn/ui. Public alpha, self-hosted.

11.4 KB
Raw Blame
import { INFRA_PROVIDER_IDS } from "./types";
import { afterEach, describe, expect, it, vi } from "vitest";
vi.mock("server-only", () => ({}));
import { doctorAdditionalProvider } from "./additional-doctor";
import { connectionCatalog } from "./connection-registry";
import { setupFields } from "./setup-guidance";
import { summarizeInfraProvider } from "./store";
const KEY = "synthetic_api_credential_for_unit_test";
afterEach(() => vi.unstubAllGlobals());
describe("additional native credential providers", () => {
  it("exposes registered native providers with guided method-specific fields", () => {
    const catalog = connectionCatalog(); expect(catalog.map((provider) => provider.id)).toEqual([...INFRA_PROVIDER_IDS]);
    for (const p of catalog) for (const m of p.sources.find(s=>s.id==="direct")!.methods) {
      expect(m.fields.length).toBeGreaterThan(0); expect(m.guidance.steps.length).toBeGreaterThan(1);
      expect(m.guidance.url).toMatch(/^https:\/\//); expect(m.guidance.reference).toMatch(/^https:\/\//);
    }
    expect(setupFields("convex-cloud", "personal").map(f => f.key)).toEqual(["personalToken"]);
    expect(setupFields("convex-cloud", "deployment").map(f => f.key)).toEqual(["deployKey", "deploymentName"]);
    expect(() => setupFields("convex-cloud", "organization")).toThrow();
    const dokuPayment = setupFields("doku","payment");
    expect(dokuPayment.map(f=>f.key)).toEqual(["paymentClientId","paymentSecretKey","paymentEnvironment"]);
    expect(dokuPayment.map(f=>f.placeholder)).toEqual(["MCH-0001-xxxxxxxxxxxxxxx","SK-EXAMPLE-DO-NOT-USE","sandbox"]);
    for (const field of dokuPayment) {
      expect(field.links?.length).toBeGreaterThan(0);
      for (const item of field.links ?? []) expect(item.url).toMatch(/^https:\/\//);
    }
    expect(dokuPayment.find(f=>f.key==="paymentEnvironment")?.description).toContain("You do not copy this");
    expect(setupFields("doku", "mcp").map(f => f.key)).toEqual(["mcpClientId", "mcpApiKey", "environment"]);
    expect(() => setupFields("doku", "direct")).toThrow();
  });
  it.each([
    ["github", "https://api.github.com/user", { apiKey: KEY }],
    ["vercel", "https://api.vercel.com/v2/user", { apiKey: KEY }],
    ["resend", "https://api.resend.com/domains", { apiKey: KEY }],
    ["stripe", "https://api.stripe.com/v1/account", { apiKey: KEY }],
    ["clerk", "https://api.clerk.com/v1/users?limit=1", { apiKey: KEY }],
    ["supabase", "https://api.supabase.com/v1/projects", { managementToken: KEY }],
    ["convex-cloud", "https://api.convex.dev/v1/list_personal_access_tokens?limit=1", { personalToken: KEY }],
    ["linear", "https://api.linear.app/graphql", { apiKey: KEY }],
  ])("checks %s at a fixed provider-owned endpoint", async (id, endpoint, values) => {
    const mock = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => new Response("[]", { status: 200 })); vi.stubGlobal("fetch", mock);
    const result = await doctorAdditionalProvider(id as string, values as Record<string, string>);
    expect(result).toContain("authenticated"); expect(result).not.toContain(KEY);
    expect(mock.mock.calls[0]?.[0]).toBe(endpoint);
  });
  it.each([401, 403])("keeps Resend Domains %s as capability-unavailable instead of credential-invalid", async (status) => {
    const mock = vi.fn(async () => new Response("scope denied", { status }));
    vi.stubGlobal("fetch", mock);
    await expect(doctorAdditionalProvider("resend", { apiKey: KEY })).rejects.toThrow(
      "Resend Domains API access unavailable; sending capability not verified"
    );
    expect(mock).toHaveBeenCalledTimes(1);
  });
  it("verifies DOKU Payment with a signed read-only synthetic status lookup",async()=>{
    const mock=vi.fn(async(input:RequestInfo|URL,init?:RequestInit)=>{expect(String(input)).toContain("api-sandbox.doku.com/orders/v1/status/MSO-CRED-CHECK-");const h=new Headers(init?.headers);expect(h.get("Client-Id")).toBe("MCH-synthetic");expect(h.get("Signature")).toMatch(/^HMACSHA256=/);return new Response(JSON.stringify({responseCode:"4040001",responseMessage:"Transaction Not Found"}),{status:404});});vi.stubGlobal("fetch",mock);
    const result=await doctorAdditionalProvider("doku",{paymentClientId:"MCH-synthetic",paymentSecretKey:KEY,paymentEnvironment:"sandbox"});expect(result).toBe("authenticated; sandbox signed status lookup verified");expect(result).not.toContain(KEY);expect(mock).toHaveBeenCalledTimes(1);
  });
  it("rejects an invalid-merchant 404 for DOKU Payment",async()=>{vi.stubGlobal("fetch",vi.fn(async()=>new Response(JSON.stringify({responseCode:"4040008",responseMessage:"Invalid Merchant"}),{status:404})));await expect(doctorAdditionalProvider("doku",{paymentClientId:"MCH-synthetic",paymentSecretKey:KEY,paymentEnvironment:"sandbox"})).rejects.toThrow("DOKU Payment HTTP 404");});
  it("verifies DOKU MCP with a fixed official endpoint and never exposes credentials", async () => {
    const mock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
      expect(String(input)).toBe("https://api-sandbox.doku.com/doku-mcp-server/mcp");
      const headers = new Headers(init?.headers);
      expect(headers.get("Client-Id")).toBe("BRN-synthetic");
      expect(headers.get("authorization")).toBe(`Basic ${Buffer.from(`${KEY}:`).toString("base64")}`);
      expect(JSON.parse(String(init?.body))).toMatchObject({ method: "initialize", id: "mso-doku-doctor" });
      return new Response(JSON.stringify({ jsonrpc: "2.0", id: "mso-doku-doctor", result: { protocolVersion: "2024-11-05", capabilities: {} } }), { status: 200, headers: { "content-type": "application/json" } });
    });
    vi.stubGlobal("fetch", mock);
    const result = await doctorAdditionalProvider("doku", { mcpClientId: "BRN-synthetic", mcpApiKey: KEY, environment: "sandbox" });
    expect(result).toBe("authenticated; sandbox MCP initialize verified");
    expect(result).not.toContain(KEY);
    expect(mock).toHaveBeenCalledTimes(1);
  });
  it("rejects arbitrary DOKU environments before sending credentials", async () => {
    const mock = vi.fn(); vi.stubGlobal("fetch", mock);
    await expect(doctorAdditionalProvider("doku", { mcpClientId: "BRN-synthetic", mcpApiKey: KEY, environment: "https://evil.invalid" })).rejects.toThrow("invalid environment");
    expect(mock).not.toHaveBeenCalled();
  });
  it("never echoes reflected provider errors or request secrets", async () => {
    vi.stubGlobal("fetch", vi.fn(async () => new Response(KEY, { status: 401 })));
    await expect(doctorAdditionalProvider("github", { apiKey: KEY })).rejects.toThrow("GitHub HTTP 401");
    vi.stubGlobal("fetch", vi.fn(async () => { throw new Error(KEY); }));
    await expect(doctorAdditionalProvider("github", { apiKey: KEY })).rejects.toThrow("GitHub request failed");
  });
  it("checks self-hosted Convex admin keys at the fixed admin endpoint", async () => {
    const mock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
      const request = input instanceof Request ? input : new Request(input, init);
      expect(request.url).toBe("http://localhost:3210/api/check_admin_key");
      expect(request.headers.get("authorization")).toBe(`Convex ${KEY}`);
      return new Response(null, { status: 200 });
    });
    vi.stubGlobal("fetch", mock);
    await expect(doctorAdditionalProvider("convex", { apiUrl: "http://localhost:3210/base", adminKey: KEY })).resolves.toBe("authenticated; deployment access verified");
    expect(mock).toHaveBeenCalledTimes(1);
  });
  it("redacts self-hosted Convex admin-key rejection responses", async () => {
    vi.stubGlobal("fetch", vi.fn(async () => new Response(KEY, { status: 403 })));
    const result = doctorAdditionalProvider("convex", { apiUrl: "http://localhost:3210", adminKey: KEY });
    await expect(result).rejects.toThrow("Convex HTTP 403");
    await expect(result).rejects.not.toThrow(KEY);
  });
  it("distinguishes an unreachable self-hosted deployment from a rejected admin key", async () => {
    // curl exit 35: the TCP/TLS connection produced no HTTP response at all.
    vi.stubGlobal("fetch", vi.fn(async () => { throw new TypeError("fetch failed"); }));
    const unreachable = doctorAdditionalProvider("convex", { apiUrl: "http://localhost:3210", adminKey: KEY });
    await expect(unreachable).rejects.toThrow(/unreachable.*no HTTP response/i);
    await expect(unreachable).rejects.not.toThrow(KEY);
    // Reachable, but the deployment rejected the key.
    vi.stubGlobal("fetch", vi.fn(async () => new Response(null, { status: 401 })));
    const rejected = doctorAdditionalProvider("convex", { apiUrl: "http://localhost:3210", adminKey: KEY });
    await expect(rejected).rejects.toThrow(/admin key rejected/i);
    await expect(rejected).rejects.toThrow("Convex HTTP 401");
    await expect(rejected).rejects.not.toThrow(KEY);
    // The two operator actions must not collapse into one message.
    vi.stubGlobal("fetch", vi.fn(async () => { throw new TypeError("fetch failed"); }));
    const first = await doctorAdditionalProvider("convex", { apiUrl: "http://localhost:3210", adminKey: KEY }).catch((error: Error) => error.message);
    vi.stubGlobal("fetch", vi.fn(async () => new Response(null, { status: 403 })));
    const second = await doctorAdditionalProvider("convex", { apiUrl: "http://localhost:3210", adminKey: KEY }).catch((error: Error) => error.message);
    expect(first).not.toBe(second);
  });
  it("rejects arbitrary Convex targets before sending any key", async () => {
    const mock = vi.fn(); vi.stubGlobal("fetch", mock);
    for (const apiUrl of ["http://169.254.169.254/", "https://owner:[email protected]", "https://example.com/?credential=x"])
      await expect(doctorAdditionalProvider("convex", { apiUrl, adminKey: KEY })).rejects.toThrow("invalid deployment URL");
    await expect(doctorAdditionalProvider("convex-cloud", { deployKey: KEY, deploymentName: "test.example.com/" })).rejects.toThrow();
    expect(mock).not.toHaveBeenCalled();
  });
  it("derives redaction from the field schema for every secret key name", () => {
    expect(JSON.stringify(summarizeInfraProvider("convex-cloud", { personalToken: KEY }))).not.toContain(KEY);
    expect(JSON.stringify(summarizeInfraProvider("convex", { adminKey: KEY, apiUrl: "https://convex.example.com" }))).not.toContain(KEY);
    expect(JSON.stringify(summarizeInfraProvider("supabase", { managementToken: KEY }))).not.toContain(KEY);
    expect(JSON.stringify(summarizeInfraProvider("doku",{paymentClientId:"MCH-synthetic",paymentSecretKey:KEY,paymentEnvironment:"sandbox"}))).not.toContain(KEY);
    expect(JSON.stringify(summarizeInfraProvider("doku", { mcpClientId: "BRN-synthetic", mcpApiKey: KEY, environment: "sandbox" }))).not.toContain(KEY);
  });
});

it("shows the verified GitHub login without claiming repository access", async () => {
  vi.stubGlobal("fetch", vi.fn(async () => new Response(JSON.stringify({ login: "account-other", email: "[email protected]", extra: KEY }), { status: 200 })));
  const result = await doctorAdditionalProvider("github", { apiKey: KEY });
  expect(result).toBe("authenticated as account-other; repository scope not verified");
  expect(result).not.toContain(KEY); expect(result).not.toContain("[email protected]");
});
it("does not echo malformed or reflected account identity", async () => {
  vi.stubGlobal("fetch", vi.fn(async () => new Response(JSON.stringify({ login: KEY }), { status: 200 })));
  const result = await doctorAdditionalProvider("github", { apiKey: KEY });
  expect(result).toContain("account identity unavailable"); expect(result).not.toContain(KEY);
});