@artifactly/mcp 0.1.5 → 0.1.7

package/package.json

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

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

@@ -1,4 +1,4 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -82,6 +82,26 @@ describe("artifactly CLI", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
+  it("logs out by removing stored credentials", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-cli-"));
+    const credentialPath = join(dir, "credentials.json");
+    const output: string[] = [];
+    const cli = createArtifactlyCli({
+      credentialPath,
+      stdout: (line) => output.push(line),
+    });
+
+    await cli.run(["login", "--api-key", "art_test_secret", "--email", "agent@example.com"]);
+    expect(existsSync(credentialPath)).toBe(true);
+
+    await cli.run(["logout"]);
+
+    expect(existsSync(credentialPath)).toBe(false);
+    expect(readCredentials(credentialPath)).toBeNull();
+    expect(output.at(-1)).toBe("Logged out of Artifactly.");
+    rmSync(dir, { recursive: true, force: true });
+  });
+
   it("reports the default credential path under the user home", () => {
     expect(getDefaultCredentialPath("/Users/alice")).toBe(
       "/Users/alice/.artifactly/credentials.json",

package/src/cli/artifactly-cli.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -73,6 +73,10 @@ export function writeCredentials(
   writeFileSync(path, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 0o600 });
 }
 
+export function clearCredentials(path = getDefaultCredentialPath()) {
+  rmSync(path, { force: true });
+}
+
 async function defaultPrompt(question: string) {
   const readline = createInterface({ input, output });
   try {
@@ -166,6 +170,11 @@ export function createArtifactlyCli(options: ArtifactlyCliOptions = {}) {
     stdout(`Workspace: ${credentials.workspace ?? "unknown"}`);
   }
 
+  function logout() {
+    clearCredentials(credentialPath);
+    stdout("Logged out of Artifactly.");
+  }
+
   async function publish(argv: string[]) {
     const credentials = readCredentials(credentialPath);
     if (!credentials) {
@@ -206,10 +215,11 @@ export function createArtifactlyCli(options: ArtifactlyCliOptions = {}) {
     const [command, ...rest] = argv;
     try {
       if (command === "login") return await login(rest);
+      if (command === "logout") return logout();
       if (command === "whoami") return whoami();
       if (command === "publish") return await publish(rest);
       if (command === "mcp") return await mcp(rest);
-      stdout("Usage: artifactly <login|whoami|publish|mcp>");
+      stdout("Usage: artifactly <login|logout|whoami|publish|mcp>");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       stderr(message);

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

@@ -42,9 +42,13 @@ describe("Artifactly MCP stdio server helpers", () => {
       "artifactly_auth_status",
       "artifactly_request_login_code",
       "artifactly_verify_login_code",
+      "artifactly_logout",
       "artifactly_publish_markdown",
       "artifactly_list_artifacts",
       "artifactly_get_artifact",
+      "artifactly_update_artifact",
+      "artifactly_delete_artifact",
+      "artifactly_publish_file",
     ]);
   });
 

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

@@ -92,6 +92,7 @@ const verifyLoginCodeSchema = z.object({
   email: z.string().email(),
   code: z.string().min(4),
 });
+const logoutSchema = z.object({});
 const publishMarkdownSchema = z.object({
   title: z.string().min(1),
   markdown: z.string().min(1),
@@ -101,14 +102,36 @@ const listArtifactsSchema = z.object({});
 const getArtifactSchema = z.object({
   artifactId: z.string().min(1),
 });
+const updateArtifactSchema = z.object({
+  artifactId: z.string().min(1),
+  title: z.string().min(1).optional(),
+  markdown: z.string().min(1).optional(),
+  content: z.string().min(1).optional(),
+  description: z.string().min(1).optional(),
+  visibility: z.enum(["public", "unlisted", "private", "gated"]).optional(),
+  accessList: z.array(z.string().email()).optional(),
+});
+const deleteArtifactSchema = z.object({
+  artifactId: z.string().min(1),
+});
+const publishFileSchema = z.object({
+  path: z.string().min(1),
+  title: z.string().min(1).optional(),
+  mimeType: z.string().min(1).optional(),
+  visibility: z.enum(["public", "unlisted", "private", "gated"]).optional(),
+});
 
 const toolSchemas = {
   artifactly_auth_status: authStatusSchema,
   artifactly_request_login_code: requestLoginCodeSchema,
   artifactly_verify_login_code: verifyLoginCodeSchema,
+  artifactly_logout: logoutSchema,
   artifactly_publish_markdown: publishMarkdownSchema,
   artifactly_list_artifacts: listArtifactsSchema,
   artifactly_get_artifact: getArtifactSchema,
+  artifactly_update_artifact: updateArtifactSchema,
+  artifactly_delete_artifact: deleteArtifactSchema,
+  artifactly_publish_file: publishFileSchema,
 } as const;
 
 export function createArtifactlyMcpServer() {

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

@@ -1,4 +1,4 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -13,9 +13,13 @@ describe("Artifactly MCP tools", () => {
       "artifactly_auth_status",
       "artifactly_request_login_code",
       "artifactly_verify_login_code",
+      "artifactly_logout",
       "artifactly_publish_markdown",
       "artifactly_list_artifacts",
       "artifactly_get_artifact",
+      "artifactly_update_artifact",
+      "artifactly_delete_artifact",
+      "artifactly_publish_file",
     ]);
   });
 
@@ -44,6 +48,72 @@ describe("Artifactly MCP tools", () => {
     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");
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_logout", credentialPath }),
+    ).resolves.toEqual({ ok: true, authenticated: false });
+    expect(existsSync(credentialPath)).toBe(false);
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_auth_status", credentialPath }),
+    ).resolves.toEqual({ authenticated: false, apiBaseUrl: "https://artifactly.io" });
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
   it("publishes markdown through the Artifactly API without returning secrets", async () => {
     const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
     const credentialPath = join(dir, "credentials.json");
@@ -88,4 +158,164 @@ describe("Artifactly MCP tools", () => {
 
     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");
+    const requests: Array<{ method: string; path: string; body?: unknown; apiKey?: string }> = [];
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    const requestJson = async (method: string, path: string, body?: unknown, options?: { apiKey?: string }) => {
+      requests.push({ method, path, body, apiKey: options?.apiKey });
+      if (method === "GET" && path === "/api/artifacts") {
+        return { artifacts: [{ id: "artifact_1", title: "Hello" }] };
+      }
+      if (method === "GET" && path === "/api/artifacts/artifact_1") {
+        return { artifact: { id: "artifact_1", title: "Hello" } };
+      }
+      if (method === "PATCH" && path === "/api/artifacts/artifact_1") {
+        return { artifact: { id: "artifact_1", title: "Updated", visibility: "private" } };
+      }
+      return { ok: true, artifactId: "artifact_1" };
+    };
+
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_list_artifacts", credentialPath, requestJson }),
+    ).resolves.toEqual({ artifacts: [{ id: "artifact_1", title: "Hello" }] });
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_get_artifact",
+        credentialPath,
+        arguments: { artifactId: "artifact_1" },
+        requestJson,
+      }),
+    ).resolves.toEqual({ artifact: { id: "artifact_1", title: "Hello" } });
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_update_artifact",
+        credentialPath,
+        arguments: {
+          artifactId: "artifact_1",
+          title: "Updated",
+          visibility: "private",
+          accessList: ["agent@example.com"],
+        },
+        requestJson,
+      }),
+    ).resolves.toEqual({ artifact: { id: "artifact_1", title: "Updated", visibility: "private" } });
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_delete_artifact",
+        credentialPath,
+        arguments: { artifactId: "artifact_1" },
+        requestJson,
+      }),
+    ).resolves.toEqual({ ok: true, artifactId: "artifact_1" });
+
+    expect(requests).toEqual([
+      { method: "GET", path: "/api/artifacts", apiKey: "art_t...et", body: undefined },
+      { method: "GET", path: "/api/artifacts/artifact_1", apiKey: "art_t...et", body: undefined },
+      {
+        method: "PATCH",
+        path: "/api/artifacts/artifact_1",
+        apiKey: "art_t...et",
+        body: { title: "Updated", visibility: "private", accessList: ["agent@example.com"] },
+      },
+      { method: "DELETE", path: "/api/artifacts/artifact_1", apiKey: "art_t...et", body: undefined },
+    ]);
+    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");
+    const htmlPath = join(dir, "hello.html");
+    const pdfPath = join(dir, "hello.pdf");
+    const requests: Array<{ path: string; body: unknown; apiKey?: string }> = [];
+    writeFileSync(htmlPath, "<h1>Hello</h1>");
+    writeFileSync(pdfPath, Buffer.from("%PDF-1.4\nhello"));
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    const postJson = async (path: string, body: unknown, options?: { apiKey?: string }) => {
+      requests.push({ path, body, apiKey: options?.apiKey });
+      return { id: "artifact_1", url: "https://artifactly.example/share/agent/hello" };
+    };
+
+    await callArtifactlyMcpTool({
+      name: "artifactly_publish_file",
+      credentialPath,
+      arguments: { path: htmlPath, visibility: "public" },
+      postJson,
+    });
+    await callArtifactlyMcpTool({
+      name: "artifactly_publish_file",
+      credentialPath,
+      arguments: { path: pdfPath, title: "PDF Hello", mimeType: "application/pdf" },
+      postJson,
+    });
+
+    expect(requests).toEqual([
+      {
+        path: "/api/artifacts",
+        apiKey: "art_t...et",
+        body: {
+          title: "hello",
+          kind: "html",
+          content: "<h1>Hello</h1>",
+          visibility: "public",
+        },
+      },
+      {
+        path: "/api/artifacts",
+        apiKey: "art_t...et",
+        body: {
+          title: "PDF Hello",
+          kind: "file",
+          storageUrl: "data:application/pdf;base64,JVBERi0xLjQKaGVsbG8=",
+          visibility: "unlisted",
+        },
+      },
+    ]);
+    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

@@ -1,4 +1,8 @@
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+
 import {
+  clearCredentials,
   createDefaultPostJson,
   getDefaultCredentialPath,
   readCredentials,
@@ -18,8 +22,41 @@ type CallToolInput = {
   credentialPath?: string;
   apiBaseUrl?: string;
   postJson?: PostJson;
+  requestJson?: RequestJson;
 };
 
+type RequestJson = (
+  method: string,
+  path: string,
+  body?: unknown,
+  options?: { apiKey?: string },
+) => Promise<unknown>;
+
+function createDefaultRequestJson(apiBaseUrl: string): RequestJson {
+  return async (method, path, body, options) => {
+    const response = await fetch(`${apiBaseUrl}${path}`, {
+      method,
+      headers: {
+        ...(body === undefined ? {} : { "content-type": "application/json" }),
+        ...(options?.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {}),
+      },
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    const payload = (await response.json().catch(() => ({}))) as unknown;
+    if (!response.ok) {
+      const message =
+        typeof payload === "object" &&
+        payload !== null &&
+        "error" in payload &&
+        typeof payload.error === "string"
+          ? payload.error
+          : `Artifactly API request failed with ${response.status}`;
+      throw new Error(message);
+    }
+    return payload;
+  };
+}
+
 function stringArg(
   args: Record<string, unknown> | undefined,
   key: string,
@@ -28,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,
@@ -39,6 +84,17 @@ function requireStringArg(
   return value;
 }
 
+function stringArrayArg(
+  args: Record<string, unknown> | undefined,
+  key: string,
+): string[] | undefined {
+  const value = args?.[key];
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  return value.filter((item): item is string => typeof item === "string");
+}
+
 function objectResult(value: unknown): Record<string, unknown> {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("Artifactly API returned an unexpected response.");
@@ -46,12 +102,58 @@ 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";
+}
+
+function inferMimeType(path: string): string {
+  const extension = extname(path).toLowerCase();
+  if (extension === ".pdf") return "application/pdf";
+  if (extension === ".html" || extension === ".htm") return "text/html";
+  if (extension === ".json") return "application/json";
+  if (extension === ".md" || extension === ".markdown") return "text/markdown";
+  if (extension === ".txt") return "text/plain";
+  return "application/octet-stream";
+}
+
+function kindForMime(path: string, mimeType: string) {
+  const extension = extname(path).toLowerCase();
+  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";
+  return "file";
+}
+
 export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
   return [
     {
       name: "artifactly_auth_status",
       description: "Check whether local Artifactly credentials are configured.",
-      inputSchema: { type: "object", properties: {} },
+      inputSchema: { type: "object", properties: { validate: { type: "boolean" } } },
     },
     {
       name: "artifactly_request_login_code",
@@ -72,6 +174,11 @@ export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
         required: ["email", "code"],
       },
     },
+    {
+      name: "artifactly_logout",
+      description: "Log out by clearing the local Artifactly credential store.",
+      inputSchema: { type: "object", properties: {} },
+    },
     {
       name: "artifactly_publish_markdown",
       description: "Publish markdown through the Artifactly API using stored credentials.",
@@ -99,6 +206,46 @@ export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
         required: ["artifactId"],
       },
     },
+    {
+      name: "artifactly_update_artifact",
+      description: "Update an existing Artifactly artifact, including visibility and gated access emails.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          artifactId: { type: "string" },
+          title: { type: "string" },
+          markdown: { type: "string" },
+          content: { type: "string" },
+          description: { type: "string" },
+          visibility: { type: "string", enum: ["public", "unlisted", "private", "gated"] },
+          accessList: { type: "array", items: { type: "string" } },
+        },
+        required: ["artifactId"],
+      },
+    },
+    {
+      name: "artifactly_delete_artifact",
+      description: "Delete an existing Artifactly artifact owned by the authenticated account.",
+      inputSchema: {
+        type: "object",
+        properties: { artifactId: { type: "string" } },
+        required: ["artifactId"],
+      },
+    },
+    {
+      name: "artifactly_publish_file",
+      description: "Publish a local PDF, HTML, JSON, Markdown, or other file through the Artifactly API.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          title: { type: "string" },
+          mimeType: { type: "string" },
+          visibility: { type: "string", enum: ["public", "unlisted", "private", "gated"] },
+        },
+        required: ["path"],
+      },
+    },
   ];
 }
 
@@ -107,16 +254,32 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
   const credentials = readCredentials(credentialPath);
   const apiBaseUrl = input.apiBaseUrl ?? credentials?.apiBaseUrl ?? "https://artifactly.io";
   const postJson = input.postJson ?? createDefaultPostJson(apiBaseUrl);
+  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") {
@@ -155,9 +318,14 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
     };
   }
 
+  if (input.name === "artifactly_logout") {
+    clearCredentials(credentialPath);
+    return { ok: true, authenticated: false };
+  }
+
   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");
@@ -172,17 +340,83 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
   }
 
   if (input.name === "artifactly_list_artifacts") {
-    return {
-      error:
-        "Artifact list API is not available yet. This MCP tool is reserved for the next API expansion.",
-    };
+    if (!credentials) {
+      throw new Error(LOGIN_GUIDANCE);
+    }
+    return objectResult(await requestJson("GET", "/api/artifacts", undefined, { apiKey: credentials.apiKey }));
   }
 
   if (input.name === "artifactly_get_artifact") {
-    return {
-      error:
-        "Artifact lookup API is not available yet. This MCP tool is reserved for the next API expansion.",
-    };
+    if (!credentials) {
+      throw new Error(LOGIN_GUIDANCE);
+    }
+    const artifactId = requireStringArg(input.arguments, "artifactId");
+    return objectResult(await requestJson("GET", `/api/artifacts/${artifactId}`, undefined, { apiKey: credentials.apiKey }));
+  }
+
+  if (input.name === "artifactly_update_artifact") {
+    if (!credentials) {
+      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 = optionalStringArg(input.arguments, "description");
+    const visibility = stringArg(input.arguments, "visibility");
+    const accessList = stringArrayArg(input.arguments, "accessList");
+    return objectResult(
+      await requestJson(
+        "PATCH",
+        `/api/artifacts/${artifactId}`,
+        {
+          ...(title ? { title } : {}),
+          ...(markdown ? { markdown } : {}),
+          ...(content ? { content } : {}),
+          ...(description !== undefined ? { description } : {}),
+          ...(visibility ? { visibility } : {}),
+          ...(accessList ? { accessList } : {}),
+        },
+        { apiKey: credentials.apiKey },
+      ),
+    );
+  }
+
+  if (input.name === "artifactly_delete_artifact") {
+    if (!credentials) {
+      throw new Error(LOGIN_GUIDANCE);
+    }
+    const artifactId = requireStringArg(input.arguments, "artifactId");
+    return objectResult(await requestJson("DELETE", `/api/artifacts/${artifactId}`, undefined, { apiKey: credentials.apiKey }));
+  }
+
+  if (input.name === "artifactly_publish_file") {
+    if (!credentials) {
+      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 = readFileForPublish(path);
+    const payload =
+      kind === "file"
+        ? {
+            title,
+            kind,
+            storageUrl: `data:${mimeType};base64,${file.toString("base64")}`,
+            visibility,
+          }
+        : {
+            title,
+            kind,
+            content: file.toString("utf8"),
+            visibility,
+          };
+    return objectResult(
+      await postJson("/api/artifacts", payload, { apiKey: credentials.apiKey }),
+    );
   }
 
   throw new Error(`Unknown Artifactly MCP tool: ${input.name}`);