@artifactly/mcp 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artifactly/mcp",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "files": [
     "bin",

package/src/cli/artifactly-cli.ts

@@ -57,9 +57,32 @@ export function getDefaultCredentialPath(home = homedir()) {
   return join(home, ".artifactly", "credentials.json");
 }
 
+function normalizeCredentials(value: unknown): ArtifactlyCredentials | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const candidate = value as Record<string, unknown>;
+  if (typeof candidate.apiBaseUrl !== "string" || !candidate.apiBaseUrl.trim()) {
+    return null;
+  }
+  if (typeof candidate.apiKey !== "string" || !candidate.apiKey.trim()) {
+    return null;
+  }
+  return {
+    apiBaseUrl: candidate.apiBaseUrl.trim(),
+    apiKey: candidate.apiKey.trim(),
+    ...(typeof candidate.email === "string" && candidate.email.trim()
+      ? { email: candidate.email.trim() }
+      : {}),
+    ...(typeof candidate.workspace === "string" && candidate.workspace.trim()
+      ? { workspace: candidate.workspace.trim() }
+      : {}),
+  };
+}
+
 export function readCredentials(path = getDefaultCredentialPath()): ArtifactlyCredentials | null {
   try {
-    return JSON.parse(readFileSync(path, "utf8")) as ArtifactlyCredentials;
+    return normalizeCredentials(JSON.parse(readFileSync(path, "utf8")));
   } catch {
     return null;
   }

package/src/mcp/artifactly-mcp-server.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 
 import packageJson from "../../package.json";
 import {
+  createArtifactlyMcpServer,
   createArtifactlyMcpCallResult,
   getArtifactlyMcpInstallConfig,
   listArtifactlyMcpServerTools,
@@ -37,6 +38,25 @@ describe("Artifactly MCP server packaging", () => {
 });
 
 describe("Artifactly MCP stdio server helpers", () => {
+  it("registers tool schemas and server info from package metadata", () => {
+    const server = createArtifactlyMcpServer() as unknown as {
+      server: { _serverInfo: { name: string; version: string } };
+      _registeredTools: Record<string, { inputSchema: { def: { shape: Record<string, unknown> }; safeParse(value: unknown): { success: boolean } } }>;
+    };
+
+    expect(server.server._serverInfo).toEqual({
+      name: "artifactly",
+      version: packageJson.version,
+    });
+    expect(Object.keys(server._registeredTools.artifactly_auth_status.inputSchema.def.shape)).toContain("validate");
+    expect(
+      server._registeredTools.artifactly_update_artifact.inputSchema.safeParse({
+        artifactId: "artifact_1",
+        description: "",
+      }).success,
+    ).toBe(true);
+  });
+
   it("maps Artifactly tools to MCP-compatible tool definitions", () => {
     expect(listArtifactlyMcpServerTools().map((tool) => tool.name)).toEqual([
       "artifactly_auth_status",

package/src/mcp/artifactly-mcp-server.ts

@@ -2,6 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 
+import packageJson from "../../package.json";
 import { callArtifactlyMcpTool, listArtifactlyMcpTools } from "./artifactly-mcp.js";
 
 export type ArtifactlyMcpInstallConfig = {
@@ -83,7 +84,9 @@ export async function createArtifactlyMcpCallResult(input: {
   }
 }
 
-const authStatusSchema = z.object({});
+const authStatusSchema = z.object({
+  validate: z.boolean().optional(),
+});
 const requestLoginCodeSchema = z.object({
   email: z.string().email(),
   name: z.string().optional(),
@@ -107,7 +110,7 @@ const updateArtifactSchema = z.object({
   title: z.string().min(1).optional(),
   markdown: z.string().min(1).optional(),
   content: z.string().min(1).optional(),
-  description: z.string().min(1).optional(),
+  description: z.string().max(500).optional(),
   visibility: z.enum(["public", "unlisted", "private", "gated"]).optional(),
   accessList: z.array(z.string().email()).optional(),
 });
@@ -137,7 +140,7 @@ const toolSchemas = {
 export function createArtifactlyMcpServer() {
   const server = new McpServer({
     name: "artifactly",
-    version: "0.1.1",
+    version: packageJson.version,
   });
 
   for (const tool of listArtifactlyMcpTools()) {

package/src/mcp/artifactly-mcp.test.ts

@@ -48,6 +48,63 @@ describe("Artifactly MCP tools", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
+  it("does not report malformed credential files as authenticated", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    writeFileSync(credentialPath, "{}\n");
+
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_auth_status", credentialPath }),
+    ).resolves.toEqual({ authenticated: false, apiBaseUrl: "https://artifactly.io" });
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_list_artifacts", credentialPath }),
+    ).rejects.toThrow(/artifactly_request_login_code[\s\S]*artifactly_verify_login_code/);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("can validate auth status against the Artifactly API", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    const requests: Array<{ method: string; path: string; apiKey?: string }> = [];
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_test_secret",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_auth_status",
+        credentialPath,
+        arguments: { validate: true },
+        requestJson: async (method, path, _body, options) => {
+          requests.push({ method, path, apiKey: options?.apiKey });
+          return { artifacts: [] };
+        },
+      }),
+    ).resolves.toMatchObject({
+      authenticated: true,
+      serverAuthenticated: true,
+      validationError: null,
+    });
+    expect(requests).toEqual([
+      { method: "GET", path: "/api/artifacts", apiKey: "art_test_secret" },
+    ]);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("gives complete login guidance when protected tools lack credentials", async () => {
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_list_artifacts", credentialPath: "/tmp/nope.json" }),
+    ).rejects.toThrow(/artifactly_request_login_code[\s\S]*artifactly_verify_login_code/);
+  });
+
   it("logs out by clearing the shared credential store", async () => {
     const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
     const credentialPath = join(dir, "credentials.json");
@@ -117,6 +174,34 @@ describe("Artifactly MCP tools", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
+  it("preserves markdown body whitespace when publishing inline markdown", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    let publishedBody: unknown;
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    await callArtifactlyMcpTool({
+      name: "artifactly_publish_markdown",
+      credentialPath,
+      arguments: { title: "Whitespace", markdown: "  # Hello\n\n" },
+      postJson: async (_path, body) => {
+        publishedBody = body;
+        return { id: "artifact_1", url: "https://artifactly.example/share/agent/hello" };
+      },
+    });
+
+    expect(publishedBody).toMatchObject({ content: "  # Hello\n\n" });
+    rmSync(dir, { recursive: true, force: true });
+  });
+
   it("lists, gets, updates, and deletes artifacts through authenticated API requests", async () => {
     const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
     const credentialPath = join(dir, "credentials.json");
@@ -192,6 +277,29 @@ describe("Artifactly MCP tools", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
+  it("rejects conflicting markdown and content update arguments with a specific error", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_update_artifact",
+        credentialPath,
+        arguments: { artifactId: "artifact_1", markdown: "# Markdown", content: "Plain" },
+      }),
+    ).rejects.toThrow(/Use either markdown or content, not both/);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
   it("publishes local HTML and PDF files through the artifact API", async () => {
     const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
     const credentialPath = join(dir, "credentials.json");
@@ -252,4 +360,61 @@ describe("Artifactly MCP tools", () => {
     ]);
     rmSync(dir, { recursive: true, force: true });
   });
+
+  it("uses explicit MIME type instead of extension when publishing files", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    const markdownPath = join(dir, "report.md");
+    let publishedBody: unknown;
+    writeFileSync(markdownPath, "# Report");
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    await callArtifactlyMcpTool({
+      name: "artifactly_publish_file",
+      credentialPath,
+      arguments: { path: markdownPath, mimeType: "application/pdf" },
+      postJson: async (_path, body) => {
+        publishedBody = body;
+        return { id: "artifact_1", url: "https://artifactly.example/share/agent/report" };
+      },
+    });
+
+    expect(publishedBody).toMatchObject({
+      kind: "file",
+      storageUrl: "data:application/pdf;base64,IyBSZXBvcnQ=",
+    });
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("returns a friendly error when publishing a missing file", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_test_secret",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_publish_file",
+        credentialPath,
+        arguments: { path: join(dir, "missing.pdf") },
+      }),
+    ).rejects.toThrow(/File not found.*missing\.pdf/);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
 });

package/src/mcp/artifactly-mcp.ts

@@ -65,6 +65,14 @@ function stringArg(
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 
+function optionalStringArg(
+  args: Record<string, unknown> | undefined,
+  key: string,
+): string | undefined {
+  const value = args?.[key];
+  return typeof value === "string" ? value.trim() : undefined;
+}
+
 function requireStringArg(
   args: Record<string, unknown> | undefined,
   key: string,
@@ -76,6 +84,17 @@ function requireStringArg(
   return value;
 }
 
+function requireRawStringArg(
+  args: Record<string, unknown> | undefined,
+  key: string,
+): string {
+  const value = args?.[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`Missing required argument: ${key}`);
+  }
+  return value;
+}
+
 function stringArrayArg(
   args: Record<string, unknown> | undefined,
   key: string,
@@ -94,6 +113,28 @@ function objectResult(value: unknown): Record<string, unknown> {
   return value as Record<string, unknown>;
 }
 
+const LOGIN_GUIDANCE =
+  "Artifactly credentials are not configured. Run artifactly_request_login_code first, then run artifactly_verify_login_code with the emailed code.";
+
+function booleanArg(args: Record<string, unknown> | undefined, key: string): boolean {
+  return args?.[key] === true;
+}
+
+function readFileForPublish(path: string): Buffer {
+  try {
+    return readFileSync(path);
+  } catch (error) {
+    const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") {
+      throw new Error(`File not found: ${path}`);
+    }
+    if (code === "EACCES" || code === "EPERM") {
+      throw new Error(`File is not readable: ${path}`);
+    }
+    throw error;
+  }
+}
+
 function titleFromPath(path: string): string {
   const name = basename(path, extname(path));
   return name || "artifact";
@@ -109,12 +150,11 @@ function inferMimeType(path: string): string {
   return "application/octet-stream";
 }
 
-function kindForMime(path: string, mimeType: string) {
-  const extension = extname(path).toLowerCase();
+function kindForMime(_path: string, mimeType: string) {
   const normalized = mimeType.toLowerCase();
-  if (normalized.includes("html") || extension === ".html" || extension === ".htm") return "html";
-  if (normalized.includes("json") || extension === ".json") return "json";
-  if (normalized.includes("markdown") || extension === ".md" || extension === ".markdown") return "markdown";
+  if (normalized.includes("html")) return "html";
+  if (normalized.includes("json")) return "json";
+  if (normalized.includes("markdown")) return "markdown";
   return "file";
 }
 
@@ -122,8 +162,9 @@ export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
   return [
     {
       name: "artifactly_auth_status",
-      description: "Check whether local Artifactly credentials are configured.",
-      inputSchema: { type: "object", properties: {} },
+      description:
+        "Check local Artifactly credentials. Pass validate: true to confirm the saved API key with the Artifactly server.",
+      inputSchema: { type: "object", properties: { validate: { type: "boolean" } } },
     },
     {
       name: "artifactly_request_login_code",
@@ -151,7 +192,8 @@ export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
     },
     {
       name: "artifactly_publish_markdown",
-      description: "Publish markdown through the Artifactly API using stored credentials.",
+      description:
+        "Publish markdown through the Artifactly API using stored credentials. Defaults to unlisted visibility; visibility can be public, unlisted, private, or gated.",
       inputSchema: {
         type: "object",
         properties: {
@@ -178,7 +220,8 @@ export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
     },
     {
       name: "artifactly_update_artifact",
-      description: "Update an existing Artifactly artifact, including visibility and gated access emails.",
+      description:
+        "Update an existing Artifactly artifact, including visibility and gated access emails. Use markdown or content, not both; description may be an empty string to clear it.",
       inputSchema: {
         type: "object",
         properties: {
@@ -204,7 +247,8 @@ export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
     },
     {
       name: "artifactly_publish_file",
-      description: "Publish a local PDF, HTML, JSON, Markdown, or other file through the Artifactly API.",
+      description:
+        "Publish a local PDF, HTML, JSON, Markdown, or other file through the Artifactly API. Defaults to unlisted visibility; explicit mimeType takes precedence over file extension.",
       inputSchema: {
         type: "object",
         properties: {
@@ -227,14 +271,29 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
   const requestJson = input.requestJson ?? createDefaultRequestJson(apiBaseUrl);
 
   if (input.name === "artifactly_auth_status") {
-    return credentials
-      ? {
-          authenticated: true,
-          apiBaseUrl: credentials.apiBaseUrl,
-          email: credentials.email,
-          workspace: credentials.workspace,
-        }
-      : { authenticated: false, apiBaseUrl };
+    if (!credentials) {
+      return { authenticated: false, apiBaseUrl };
+    }
+
+    const result: Record<string, unknown> = {
+      authenticated: true,
+      apiBaseUrl: credentials.apiBaseUrl,
+      email: credentials.email,
+      workspace: credentials.workspace,
+    };
+
+    if (booleanArg(input.arguments, "validate")) {
+      try {
+        await requestJson("GET", "/api/artifacts", undefined, { apiKey: credentials.apiKey });
+        result.serverAuthenticated = true;
+        result.validationError = null;
+      } catch (error) {
+        result.serverAuthenticated = false;
+        result.validationError = error instanceof Error ? error.message : "Validation failed";
+      }
+    }
+
+    return result;
   }
 
   if (input.name === "artifactly_request_login_code") {
@@ -280,10 +339,10 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
 
   if (input.name === "artifactly_publish_markdown") {
     if (!credentials) {
-      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+      throw new Error(LOGIN_GUIDANCE);
     }
     const title = requireStringArg(input.arguments, "title");
-    const content = requireStringArg(input.arguments, "markdown");
+    const content = requireRawStringArg(input.arguments, "markdown");
     const visibility = stringArg(input.arguments, "visibility") ?? "unlisted";
     return objectResult(
       await postJson(
@@ -296,14 +355,14 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
 
   if (input.name === "artifactly_list_artifacts") {
     if (!credentials) {
-      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+      throw new Error(LOGIN_GUIDANCE);
     }
     return objectResult(await requestJson("GET", "/api/artifacts", undefined, { apiKey: credentials.apiKey }));
   }
 
   if (input.name === "artifactly_get_artifact") {
     if (!credentials) {
-      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+      throw new Error(LOGIN_GUIDANCE);
     }
     const artifactId = requireStringArg(input.arguments, "artifactId");
     return objectResult(await requestJson("GET", `/api/artifacts/${artifactId}`, undefined, { apiKey: credentials.apiKey }));
@@ -311,13 +370,16 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
 
   if (input.name === "artifactly_update_artifact") {
     if (!credentials) {
-      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+      throw new Error(LOGIN_GUIDANCE);
     }
     const artifactId = requireStringArg(input.arguments, "artifactId");
     const title = stringArg(input.arguments, "title");
-    const markdown = stringArg(input.arguments, "markdown");
-    const content = stringArg(input.arguments, "content");
-    const description = stringArg(input.arguments, "description");
+    const markdown = optionalStringArg(input.arguments, "markdown");
+    const content = optionalStringArg(input.arguments, "content");
+    if (markdown !== undefined && content !== undefined) {
+      throw new Error("Use either markdown or content, not both.");
+    }
+    const description = optionalStringArg(input.arguments, "description");
     const visibility = stringArg(input.arguments, "visibility");
     const accessList = stringArrayArg(input.arguments, "accessList");
     return objectResult(
@@ -328,7 +390,7 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
           ...(title ? { title } : {}),
           ...(markdown ? { markdown } : {}),
           ...(content ? { content } : {}),
-          ...(description ? { description } : {}),
+          ...(description !== undefined ? { description } : {}),
           ...(visibility ? { visibility } : {}),
           ...(accessList ? { accessList } : {}),
         },
@@ -339,7 +401,7 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
 
   if (input.name === "artifactly_delete_artifact") {
     if (!credentials) {
-      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+      throw new Error(LOGIN_GUIDANCE);
     }
     const artifactId = requireStringArg(input.arguments, "artifactId");
     return objectResult(await requestJson("DELETE", `/api/artifacts/${artifactId}`, undefined, { apiKey: credentials.apiKey }));
@@ -347,14 +409,14 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
 
   if (input.name === "artifactly_publish_file") {
     if (!credentials) {
-      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+      throw new Error(LOGIN_GUIDANCE);
     }
     const path = requireStringArg(input.arguments, "path");
     const title = stringArg(input.arguments, "title") ?? titleFromPath(path);
     const mimeType = stringArg(input.arguments, "mimeType") ?? inferMimeType(path);
     const visibility = stringArg(input.arguments, "visibility") ?? "unlisted";
     const kind = kindForMime(path, mimeType);
-    const file = readFileSync(path);
+    const file = readFileForPublish(path);
     const payload =
       kind === "file"
         ? {