mcpill 1.2.4 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpill",
-  "version": "1.2.4",
+  "version": "1.5.0",
   "type": "module",
   "description": "CLI for building, validating, and publishing MCP servers using the pill format.",
   "homepage": "https://mcpill.ruco.dev",
@@ -11,6 +11,11 @@
   "bugs": {
     "url": "https://github.com/ruco-dev/mcpill/issues"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "bin": {
     "mcpill": "./dist/cli.js"
   },

package/src/__tests__/init.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { runInit } from "../commands/init.js";
-
-describe("runInit", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-init-"));
-    dirs.push(d);
-    return d;
-  }
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("scaffolds the expected files and directories", async () => {
-    const base = mkTmp();
-    vi.spyOn(console, "log").mockImplementation(() => {});
-
-    await runInit({ dir: base });
-
-    const mcpillDir = path.join(base, ".mcpill");
-    const serverDir = path.join(mcpillDir, "server");
-
-    expect(fs.existsSync(mcpillDir)).toBe(true);
-    expect(fs.existsSync(path.join(mcpillDir, "server.md"))).toBe(true);
-    expect(fs.existsSync(path.join(mcpillDir, "pill-agent-guide.md"))).toBe(true);
-    expect(fs.existsSync(path.join(mcpillDir, "pill-user-guide.md"))).toBe(true);
-    expect(fs.existsSync(path.join(serverDir, "mcpill.config.json"))).toBe(true);
-    expect(fs.existsSync(path.join(serverDir, "tools", "echo.md"))).toBe(true);
-    expect(fs.existsSync(path.join(serverDir, "prompts", "greeting.md"))).toBe(true);
-    expect(fs.existsSync(path.join(base, "PILL.md"))).toBe(true);
-    expect(fs.existsSync(path.join(base, "README.md"))).toBe(false);
-    expect(fs.existsSync(path.join(base, "package.json"))).toBe(false);
-
-    const config = JSON.parse(
-      fs.readFileSync(path.join(serverDir, "mcpill.config.json"), "utf-8")
-    );
-    expect(config).toMatchObject({ name: path.basename(base), transport: "stdio", port: 3333 });
-
-    const serverMd = fs.readFileSync(path.join(mcpillDir, "server.md"), "utf-8");
-    expect(serverMd).toContain(`name: ${path.basename(base)}`);
-
-    const pillMd = fs.readFileSync(path.join(base, "PILL.md"), "utf-8");
-    expect(pillMd).toContain(".mcpill/pill-agent-guide.md");
-  });
-
-  it("exits with code 1 and correct message when .mcpill/ already exists", async () => {
-    const base = mkTmp();
-    vi.spyOn(console, "log").mockImplementation(() => {});
-    vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await runInit({ dir: base });
-
-    const exitSpy = vi
-      .spyOn(process, "exit")
-      .mockImplementation((_code?: number | string | null) => {
-        throw new Error("process.exit called");
-      });
-    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await expect(runInit({ dir: base })).rejects.toThrow("process.exit called");
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(errSpy).toHaveBeenCalledWith(
-      ".mcpill/ already exists. Remove it manually to re-init."
-    );
-  });
-});

package/src/__tests__/loaders/config.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { loadConfig } from "../../loaders/config.js";
-
-describe("loadConfig", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-config-"));
-    dirs.push(d);
-    return d;
-  }
-
-  afterEach(() => {
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("returns defaults when no mcpill.config.json exists", async () => {
-    const dir = mkTmp();
-    const config = await loadConfig(dir);
-    expect(config).toEqual({ name: "mcpill-server", transport: "stdio", port: 3333 });
-  });
-
-  it("file values override defaults", async () => {
-    const dir = mkTmp();
-    fs.writeFileSync(
-      path.join(dir, "mcpill.config.json"),
-      JSON.stringify({ name: "my-server", port: 4000 })
-    );
-    const config = await loadConfig(dir);
-    expect(config).toEqual({ name: "my-server", transport: "stdio", port: 4000 });
-  });
-
-  it("CLI opts override file values", async () => {
-    const dir = mkTmp();
-    fs.writeFileSync(
-      path.join(dir, "mcpill.config.json"),
-      JSON.stringify({ transport: "http", port: 4444 })
-    );
-    const config = await loadConfig(dir);
-
-    // Simulate CLI opt override (same merge logic used in runServer)
-    const cliOpts = { transport: "stdio" as const, port: 9999 };
-    const finalTransport = cliOpts.transport ?? config.transport;
-    const finalPort = cliOpts.port ?? config.port;
-
-    expect(finalTransport).toBe("stdio");
-    expect(finalPort).toBe(9999);
-  });
-});

package/src/__tests__/loaders/prompts.test.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { loadPrompts } from "../../loaders/prompts.js";
-
-describe("loadPrompts", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-prompts-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function writePrompts(dir: string, content: string) {
-    fs.writeFileSync(path.join(dir, "prompts.json"), content);
-  }
-
-  afterEach(() => {
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("parses valid JSON correctly", async () => {
-    const dir = mkTmp();
-    writePrompts(
-      dir,
-      JSON.stringify([
-        {
-          name: "summarize",
-          description: "Summarize text",
-          args: { text: { type: "string" }, count: { type: "number" } },
-          messages: [{ role: "user", content: "Summarize: {{text}}" }],
-        },
-      ])
-    );
-    const prompts = await loadPrompts(dir);
-    expect(prompts).toHaveLength(1);
-    expect(prompts[0]!.name).toBe("summarize");
-    expect(Object.keys(prompts[0]!.argsShape)).toEqual(["text", "count"]);
-  });
-
-  it("throws on invalid JSON", async () => {
-    const dir = mkTmp();
-    writePrompts(dir, `{ not valid json`);
-    await expect(loadPrompts(dir)).rejects.toThrow("prompts.json is not valid JSON:");
-  });
-
-  it("throws when file is missing", async () => {
-    const dir = mkTmp();
-    await expect(loadPrompts(dir)).rejects.toThrow("prompts.json is not valid JSON:");
-  });
-
-  it("throws on unsupported arg type", async () => {
-    const dir = mkTmp();
-    writePrompts(
-      dir,
-      JSON.stringify([
-        {
-          name: "greet",
-          args: { user: { type: "object" } },
-          messages: [],
-        },
-      ])
-    );
-    await expect(loadPrompts(dir)).rejects.toThrow(
-      "Prompt 'greet': arg 'user' uses unsupported type 'object'. Supported: string, number, boolean"
-    );
-  });
-
-  it("interpolates {{placeholder}} in message content", async () => {
-    const dir = mkTmp();
-    writePrompts(
-      dir,
-      JSON.stringify([
-        {
-          name: "greet",
-          args: { name: { type: "string" } },
-          messages: [{ role: "user", content: "Hello, {{name}}!" }],
-        },
-      ])
-    );
-    const prompts = await loadPrompts(dir);
-    const { messages } = prompts[0]!;
-
-    // Replicate the interpolation logic from run.ts
-    const args: Record<string, unknown> = { name: "world" };
-    const result = messages.map((m) => ({
-      role: m.role,
-      content: m.content.replace(
-        /\{\{(\w+)\}\}/g,
-        (_, k: string) => String(args[k] ?? "")
-      ),
-    }));
-
-    expect(result[0]!.content).toBe("Hello, world!");
-  });
-
-  it("handles prompts with no args", async () => {
-    const dir = mkTmp();
-    writePrompts(
-      dir,
-      JSON.stringify([
-        {
-          name: "hello",
-          args: {},
-          messages: [{ role: "user", content: "Hello!" }],
-        },
-      ])
-    );
-    const prompts = await loadPrompts(dir);
-    expect(prompts[0]!.argsShape).toEqual({});
-  });
-});

package/src/__tests__/loaders/resources.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { loadResources } from "../../loaders/resources.js";
-
-describe("loadResources", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-resources-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function writeResources(dir: string, content: string) {
-    fs.writeFileSync(path.join(dir, "resources.md"), content);
-  }
-
-  afterEach(() => {
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("parses a single resource block", async () => {
-    const dir = mkTmp();
-    writeResources(
-      dir,
-      "uri: config://app\nname: App Config\n---\nThis is the config resource."
-    );
-    const resources = await loadResources(dir);
-    expect(resources).toHaveLength(1);
-    expect(resources[0]!.uri).toBe("config://app");
-    expect(resources[0]!.name).toBe("App Config");
-    expect(resources[0]!.content).toBe("This is the config resource.");
-  });
-
-  it("parses multiple resource blocks", async () => {
-    const dir = mkTmp();
-    writeResources(
-      dir,
-      [
-        "uri: config://app\nname: App Config",
-        "Config content here.",
-        "uri: data://schema\nname: Schema",
-        "Schema content here.",
-      ].join("\n---\n")
-    );
-    const resources = await loadResources(dir);
-    expect(resources).toHaveLength(2);
-    expect(resources[0]!.uri).toBe("config://app");
-    expect(resources[1]!.uri).toBe("data://schema");
-    expect(resources[1]!.content).toBe("Schema content here.");
-  });
-
-  it("throws when a block is missing uri", async () => {
-    const dir = mkTmp();
-    writeResources(dir, "name: App Config\n---\nSome content.");
-    await expect(loadResources(dir)).rejects.toThrow(
-      "resources.md block 1 is missing required frontmatter field: uri"
-    );
-  });
-
-  it("handles empty body gracefully", async () => {
-    const dir = mkTmp();
-    writeResources(dir, "uri: config://app\n---\n");
-    const resources = await loadResources(dir);
-    expect(resources[0]!.content).toBe("");
-  });
-
-  it("throws when resources.md is missing", async () => {
-    const dir = mkTmp();
-    await expect(loadResources(dir)).rejects.toThrow();
-  });
-
-  it("parses optional mimeType from frontmatter", async () => {
-    const dir = mkTmp();
-    writeResources(
-      dir,
-      "uri: config://app\nmimeType: application/json\n---\n{}"
-    );
-    const resources = await loadResources(dir);
-    expect(resources[0]!.mimeType).toBe("application/json");
-  });
-});

package/src/__tests__/loaders/tools.test.ts

@@ -1,128 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { loadTools } from "../../loaders/tools.js";
-
-// CJS-format tools.js files work reliably in temp dirs without needing
-// a package.json with "type":"module" — Node exposes module.exports as .default
-// when imported via import().
-
-describe("loadTools", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-tools-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function writeTools(dir: string, content: string) {
-    fs.writeFileSync(path.join(dir, "tools.js"), content);
-  }
-
-  afterEach(() => {
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("valid tools.js export passes", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [
-        { name: "read_file", description: "Read a file", schema: {}, handler: async () => ({}) }
-      ]`
-    );
-    const tools = await loadTools(dir);
-    expect(tools).toHaveLength(1);
-    expect(tools[0]!.name).toBe("read_file");
-    expect(tools[0]!.description).toBe("Read a file");
-  });
-
-  it("throws when tools.js is missing", async () => {
-    const dir = mkTmp();
-    await expect(loadTools(dir)).rejects.toThrow("tools.js failed to load:");
-  });
-
-  it("throws when tools.js has a syntax error", async () => {
-    const dir = mkTmp();
-    writeTools(dir, `module.exports = [{ this is broken syntax`);
-    await expect(loadTools(dir)).rejects.toThrow("tools.js failed to load:");
-  });
-
-  it("throws when default export is not an array", async () => {
-    const dir = mkTmp();
-    writeTools(dir, `module.exports = { name: "not-an-array" }`);
-    await expect(loadTools(dir)).rejects.toThrow(
-      "tools.js failed to load: default export must be an array"
-    );
-  });
-
-  it("throws when name is missing", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ description: "no name", schema: {}, handler: async () => ({}) }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool at index 0 is missing required field: name"
-    );
-  });
-
-  it("throws when description is missing", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "t", schema: {}, handler: async () => ({}) }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool at index 0 is missing required field: description"
-    );
-  });
-
-  it("throws when schema is missing", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "t", description: "d", handler: async () => ({}) }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool at index 0 is missing required field: schema"
-    );
-  });
-
-  it("throws when handler is missing", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "t", description: "d", schema: {} }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool at index 0 is missing required field: handler"
-    );
-  });
-
-  it("throws when handler is not a function", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "t", description: "d", schema: {}, handler: "not-a-function" }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool 't': handler must be a function"
-    );
-  });
-
-  it("throws when schema field is a plain value instead of a Zod type", async () => {
-    const dir = mkTmp();
-    writeTools(
-      dir,
-      `module.exports = [{ name: "foo", description: "d", schema: { input: { type: "string" } }, handler: async () => ({}) }]`
-    );
-    await expect(loadTools(dir)).rejects.toThrow(
-      "Tool 'foo': schema field 'input' must be a Zod type"
-    );
-  });
-});

package/src/__tests__/pack.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { runPack, SERVER_ENTRY_TEMPLATE } from "../commands/pack.js";
-
-function scaffoldPill(baseDir: string, name = "test-pill") {
-  const mcpillDir = path.join(baseDir, ".mcpill", "server");
-  fs.mkdirSync(mcpillDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(mcpillDir, "tools.js"),
-    `module.exports = [{ name: "t", description: "d", schema: {}, handler: async () => ({}) }]`
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "prompts.json"),
-    JSON.stringify([{ name: "p", args: {}, messages: [] }])
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "resources.md"),
-    "uri: config://app\n---\nContent."
-  );
-  fs.writeFileSync(
-    path.join(mcpillDir, "mcpill.config.json"),
-    JSON.stringify({ name, transport: "stdio", port: 3333 })
-  );
-}
-
-describe("runPack", () => {
-  const dirs: string[] = [];
-
-  function mkTmp(): string {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), "mcpill-pack-"));
-    dirs.push(d);
-    return d;
-  }
-
-  function mockExit() {
-    return vi
-      .spyOn(process, "exit")
-      .mockImplementation((_code?: number | string | null) => {
-        throw new Error("process.exit called");
-      });
-  }
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    for (const d of dirs.splice(0)) {
-      fs.rmSync(d, { recursive: true, force: true });
-    }
-  });
-
-  it("writes bin/server.js with SERVER_ENTRY_TEMPLATE", async () => {
-    const base = mkTmp();
-    scaffoldPill(base);
-    vi.spyOn(console, "log").mockImplementation(() => {});
-
-    await runPack(base);
-
-    const serverJs = fs.readFileSync(path.join(base, "bin", "server.js"), "utf-8");
-    expect(serverJs).toBe(SERVER_ENTRY_TEMPLATE);
-  });
-
-  it("writes package.json with bin entry and mcpill-runtime dependency", async () => {
-    const base = mkTmp();
-    scaffoldPill(base);
-    vi.spyOn(console, "log").mockImplementation(() => {});
-
-    await runPack(base);
-
-    const pkg = JSON.parse(fs.readFileSync(path.join(base, "package.json"), "utf-8"));
-    expect(pkg.bin).toHaveProperty("test-pill");
-    expect(pkg.dependencies["mcpill-runtime"]).toBe("^0.1.0");
-  });
-
-  it("does not overwrite existing name/version in package.json", async () => {
-    const base = mkTmp();
-    scaffoldPill(base);
-    fs.writeFileSync(
-      path.join(base, "package.json"),
-      JSON.stringify({ name: "my-pill", version: "1.2.3" }, null, 2)
-    );
-    vi.spyOn(console, "log").mockImplementation(() => {});
-
-    await runPack(base);
-
-    const pkg = JSON.parse(fs.readFileSync(path.join(base, "package.json"), "utf-8"));
-    expect(pkg.name).toBe("my-pill");
-    expect(pkg.version).toBe("1.2.3");
-  });
-
-  it("throws when no pill directory is present", async () => {
-    const base = mkTmp();
-    mockExit();
-    vi.spyOn(console, "error").mockImplementation(() => {});
-
-    await expect(runPack(base)).rejects.toThrow();
-  });
-});