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.

4.7 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from "vitest";

const mocks = vi.hoisted(() => ({
  findOrCreate: vi.fn(), get: vi.fn(),
  newId: vi.fn(() => "20260901_120000_11223344"),
}));
vi.mock("@/lib/agent/session-store", () => ({ findOrCreateAgentSessionForConversation: mocks.findOrCreate, getAgentSession: mocks.get }));
vi.mock("@/lib/agent/session-files", () => ({ newAgentSessionId: mocks.newId }));

const { resolveMcpSession } = await import("./session-context");

const req = (transport = "transport-a") => new Request("https://mso.test/mcp", { headers: { "Mcp-Session-Id": transport } });
const call = (conversation?: string) => ({
  id: 1, method: "tools/call",
  params: { name: "sys_stats", arguments: {}, ...(conversation ? { _meta: { "openai/session": conversation } } : {}) },
});

describe("MCP conversation/session correlation", () => {
  beforeEach(() => {
    mocks.findOrCreate.mockReset().mockImplementation(async (_principal: string, hash: string) => ({ id: `s-${hash.slice(0, 10)}`, source: "mcp" }));
    mocks.newId.mockClear();
  });

  it("uses the same durable session across transport-id rotation for one ChatGPT conversation", async () => {
    const a = await resolveMcpSession(req("transport-a"), call("conversation-A"), "mcp-client:x", "MSO");
    const b = await resolveMcpSession(req("transport-b"), call("conversation-A"), "mcp-client:x", "MSO");
    expect("response" in a || "response" in b).toBe(false);
    if ("response" in a || "response" in b) return;
    expect(a.agentSessionId).toBe(b.agentSessionId);
    expect(a.responseSessionId).toBe("transport-a");
    expect(b.responseSessionId).toBe("transport-b");
    expect(a.conversationBound).toBe(true);
    expect(mocks.findOrCreate.mock.calls[0][1]).toMatch(/^[a-f0-9]{64}$/);
    expect(mocks.findOrCreate.mock.calls[0][1]).not.toContain("conversation-A");
  });

  it("separates two ChatGPT conversations using the same authenticated client", async () => {
    const a = await resolveMcpSession(req(), call("conversation-A"), "mcp-client:x", "MSO");
    const b = await resolveMcpSession(req(), call("conversation-B"), "mcp-client:x", "MSO");
    if ("response" in a || "response" in b) throw new Error("unexpected response");
    expect(a.agentSessionId).not.toBe(b.agentSessionId);
    expect(mocks.findOrCreate.mock.calls[0][1]).not.toBe(mocks.findOrCreate.mock.calls[1][1]);
  });

  it("keeps legacy transport fallback isolated instead of merging all token calls", async () => {
    const a = await resolveMcpSession(req("legacy-a"), call(), "mcp-client:x", "MSO");
    const b = await resolveMcpSession(req("legacy-b"), call(), "mcp-client:x", "MSO");
    if ("response" in a || "response" in b) throw new Error("unexpected response");
    expect(a.conversationBound).toBe(false);
    expect(a.agentSessionId).not.toBe(b.agentSessionId);
  });

  it("initialize allocates transport compatibility only and does not create durable agent state", async () => {
    const result = await resolveMcpSession(req(), { id: 1, method: "initialize" }, "mcp-client:x", "MSO");
    if ("response" in result) throw new Error("unexpected response");
    expect(result.responseSessionId).toBe("20260901_120000_11223344");
    expect(result.agentSessionId).toBeUndefined();
    expect(mocks.findOrCreate).not.toHaveBeenCalled();
  });

  it("auto-provisions a persistent default session when client sends no session metadata or header", async () => {
    const bare = new Request("https://mso.test/mcp");
    const result = await resolveMcpSession(bare, call(), "mcp-client:x", "Antigravity");
    if ("response" in result) throw new Error("unexpected error response");
    expect(result.conversationBound).toBe(false);
    expect(result.agentSessionId).toBeTruthy();
    expect(result.responseSessionId).toBe(result.agentSessionId);
    expect(mocks.findOrCreate).toHaveBeenCalledWith(
      "mcp-client:x",
      expect.stringMatching(/^[a-f0-9]{64}$/),
      "Default · Antigravity"
    );
  });
});

it("bootstraps without transport state and rejects a foreign explicit application session", async () => {
  const bare = new Request("https://mso.test/mcp");
  expect(await resolveMcpSession(bare, { method: "tools/call", params: { name: "agent_session_open" } }, "mcp-client:x", "")).toMatchObject({ conversationBound: false });
  mocks.get.mockResolvedValueOnce(null);
  const denied = await resolveMcpSession(bare, { method: "tools/call", params: { name: "sys_stats", _meta: { "mso/sessionId": "foreign" } } }, "mcp-client:x", "");
  expect("response" in denied && denied.response.status).toBe(403);
  mocks.get.mockResolvedValueOnce({ id: "owned" });
  expect(await resolveMcpSession(bare, { method: "tools/call", params: { name: "sys_stats", _meta: { "mso/sessionId": "owned" } } }, "mcp-client:x", "")).toMatchObject({ agentSessionId: "owned" });
});