From 206d006484dc8d1659e5cf44768eb47b3a5e53ff Mon Sep 17 00:00:00 2001
From: Ben Bolte <ben@bolte.cc>
Date: Sun, 18 Aug 2024 20:18:58 -0700
Subject: [PATCH] full urdf uploading (#299)

* full urdf uploading

* more changes

* more fixes

* working, mostly

* fix lint

* fix tests
---
 frontend/src/components/footer/Footer.tsx     |   7 +-
 .../src/components/listing/FileUpload.tsx     |   5 +-
 .../src/components/listing/ListingBody.tsx    |  17 +-
 .../components/listing/ListingFileUpload.tsx  |  32 +-
 .../src/components/listing/ListingFooter.tsx  |   2 +-
 .../src/components/listing/ListingHeader.tsx  |   2 +-
 .../src/components/listing/ListingImages.tsx  | 107 +++----
 .../src/components/listing/ListingMeshes.tsx  |  23 +-
 .../src/components/listing/ListingUrdf.tsx    | 299 ++++++++++++++++++
 .../src/components/listing/MeshRenderer.tsx   | 109 ++-----
 .../components/listings/ListingGridCard.tsx   |  12 +-
 frontend/src/components/ui/Toast.tsx          |   4 +-
 frontend/src/gen/api.ts                       | 210 ++++++++++--
 frontend/src/hooks/api.tsx                    |  34 +-
 frontend/src/pages/Browse.tsx                 |   8 +
 frontend/src/pages/ListingDetails.tsx         |   6 +-
 store/app/crud/artifacts.py                   | 118 ++++---
 store/app/crud/base.py                        |  14 +-
 store/app/crud/listings.py                    |   6 +-
 store/app/crud/urdf.py                        | 146 +++++++++
 store/app/db.py                               |   2 +
 store/app/main.py                             |   3 +
 store/app/model.py                            | 164 ++++++++--
 store/app/routers/artifacts.py                | 107 ++++---
 store/app/routers/listings.py                 |  63 +---
 store/app/routers/urdf.py                     | 128 ++++++++
 store/requirements.txt                        |   1 +
 store/settings/environment.py                 |   2 +-
 tests/test_images.py                          |   5 +-
 tests/test_listings.py                        |  57 +++-
 30 files changed, 1239 insertions(+), 454 deletions(-)
 create mode 100644 frontend/src/components/listing/ListingUrdf.tsx
 create mode 100644 store/app/crud/urdf.py
 create mode 100644 store/app/routers/urdf.py

diff --git a/frontend/src/components/footer/Footer.tsx b/frontend/src/components/footer/Footer.tsx
index aaebfd46..1a0fb04a 100644
--- a/frontend/src/components/footer/Footer.tsx
+++ b/frontend/src/components/footer/Footer.tsx
@@ -27,6 +27,7 @@ const Footer = () => {
   return (
     <footer className="bg-gray-50 dark:bg-gray-800 text-sm py-20">
       <div className="flex flex-col gap-4 mx-12 sm:mx-36">
+        {/* Logo and Social Links */}
         <div className="flex flex-row justify-between items-center">
           <span className="text-xl sm:text-2xl">K-Scale Store</span>
           <div className="flex flex-row gap-4 rounded-full">
@@ -56,7 +57,9 @@ const Footer = () => {
             </SocialLink>
           </div>
         </div>
-        <div className="flex flex-row gap-32 sm:gap-56 md:gap-64">
+
+        {/* Footer Links */}
+        <div className="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4">
           <div className="flex flex-col items-start gap-2 sm:gap-3">
             <h2 className="text-base sm:text-lg font-semibold mb-1">Company</h2>
             <a
@@ -93,6 +96,8 @@ const Footer = () => {
             </a>
           </div>
         </div>
+
+        {/* Copy Right */}
         <div className="mt-10 text-xs">
           <p>
             <span>©</span> {new Date().getFullYear()} K-Scale Labs
diff --git a/frontend/src/components/listing/FileUpload.tsx b/frontend/src/components/listing/FileUpload.tsx
index 70bca858..4ebfbdda 100644
--- a/frontend/src/components/listing/FileUpload.tsx
+++ b/frontend/src/components/listing/FileUpload.tsx
@@ -76,10 +76,7 @@ export const FileUploader = forwardRef<
     const [isFileTooBig, setIsFileTooBig] = useState(false);
     const [activeIndex, setActiveIndex] = useState(-1);
     const {
-      accept = {
-        "image/*": [".jpg", ".jpeg", ".png", ".gif", ".webp"],
-        "application/xml": [".urdf"],
-      },
+      accept,
       maxSize = 4 * 1024 * 1024,
       multiple = true,
     } = dropzoneOptions;
diff --git a/frontend/src/components/listing/ListingBody.tsx b/frontend/src/components/listing/ListingBody.tsx
index f3c4b832..8703db57 100644
--- a/frontend/src/components/listing/ListingBody.tsx
+++ b/frontend/src/components/listing/ListingBody.tsx
@@ -1,8 +1,9 @@
 import { paths } from "gen/api";
 
-import ListingArtifacts from "./ListingArtifacts";
-import ListingChildren from "./ListingChildren";
-import ListingDescription from "./ListingDescription";
+import ListingArtifacts from "components/listing/ListingArtifacts";
+import ListingChildren from "components/listing/ListingChildren";
+import ListingDescription from "components/listing/ListingDescription";
+import ListingUrdf from "components/listing/ListingUrdf";
 
 type ListingResponse =
   paths["/listings/{id}"]["get"]["responses"][200]["content"]["application/json"];
@@ -18,13 +19,11 @@ const ListingBody = (props: ListingBodyProps) => {
       <ListingDescription
         listingId={listing.id}
         description={listing.description}
-        edit={listing.owner_is_user}
+        edit={listing.can_edit}
       />
-      <ListingChildren
-        child_ids={listing.child_ids}
-        edit={listing.owner_is_user}
-      />
-      <ListingArtifacts listingId={listing.id} edit={listing.owner_is_user} />
+      <ListingChildren child_ids={listing.child_ids} edit={listing.can_edit} />
+      <ListingUrdf listingId={listing.id} edit={listing.can_edit} />
+      <ListingArtifacts listingId={listing.id} edit={listing.can_edit} />
     </div>
   );
 };
diff --git a/frontend/src/components/listing/ListingFileUpload.tsx b/frontend/src/components/listing/ListingFileUpload.tsx
index eec605f8..cc214d51 100644
--- a/frontend/src/components/listing/ListingFileUpload.tsx
+++ b/frontend/src/components/listing/ListingFileUpload.tsx
@@ -1,4 +1,5 @@
 import { useCallback, useState } from "react";
+import { DropzoneOptions } from "react-dropzone";
 
 import { components } from "gen/api";
 import { useAlertQueue } from "hooks/useAlertQueue";
@@ -15,16 +16,14 @@ import {
 import Spinner from "components/ui/Spinner";
 
 interface Props {
-  accept: {
-    [key: string]: string[];
-  };
-  maxSize: number;
+  description: string;
   listingId: string;
+  dropzoneOptions: DropzoneOptions;
   onUpload: (artifact: components["schemas"]["UploadArtifactResponse"]) => void;
 }
 
 const ListingFileUpload = (props: Props) => {
-  const { accept, maxSize, listingId, onUpload } = props;
+  const { description, listingId, dropzoneOptions, onUpload } = props;
 
   const { addErrorAlert } = useAlertQueue();
   const auth = useAuthentication();
@@ -39,9 +38,7 @@ const ListingFileUpload = (props: Props) => {
 
     setUploading(true);
     (async () => {
-      const { data, error } = await auth.api.upload(files, {
-        listing_id: listingId,
-      });
+      const { data, error } = await auth.api.upload(files, listingId);
 
       if (error) {
         addErrorAlert(error);
@@ -53,7 +50,9 @@ const ListingFileUpload = (props: Props) => {
     })();
   }, [files, auth, listingId, addErrorAlert]);
 
-  const fileExtensions = Object.values(accept).flat();
+  const fileExtensions = dropzoneOptions.accept
+    ? Object.values(dropzoneOptions.accept).flat()
+    : undefined;
 
   return uploading ? (
     <div className="w-full flex justify-center mt-4">
@@ -63,19 +62,18 @@ const ListingFileUpload = (props: Props) => {
     <FileUploader
       value={files}
       onValueChange={setFiles}
-      dropzoneOptions={{
-        accept,
-        maxSize,
-      }}
+      dropzoneOptions={dropzoneOptions}
       className="relative bg-background mt-4 rounded-lg"
     >
       <FileInput>
         <div className="flex justify-center w-full h-32">
           <div className="align-middle h-full justify-center flex flex-col">
-            <div className="text-center">Drag and drop or click to browse</div>
-            <div className="text-center">
-              File extensions: {fileExtensions.join(", ")}
-            </div>
+            <div className="text-center">{description}</div>
+            {fileExtensions && (
+              <div className="text-center">
+                File extensions: {fileExtensions.join(", ")}
+              </div>
+            )}
           </div>
         </div>
       </FileInput>
diff --git a/frontend/src/components/listing/ListingFooter.tsx b/frontend/src/components/listing/ListingFooter.tsx
index ec152d45..41faf788 100644
--- a/frontend/src/components/listing/ListingFooter.tsx
+++ b/frontend/src/components/listing/ListingFooter.tsx
@@ -7,7 +7,7 @@ interface Props {
 
 const ListingFooter = ({ listingId, edit }: Props) => {
   return (
-    <div className="relative border-t p-4">
+    <div className="relative p-4">
       <div className="grid grid-cols-1 md:grid-cols-[1fr_auto] gap-4 items-center">
         <div className="text-gray-600 dark:text-gray-300 italic text-sm">
           {`Listing ID: ${listingId}`}
diff --git a/frontend/src/components/listing/ListingHeader.tsx b/frontend/src/components/listing/ListingHeader.tsx
index 781aee07..25eb49ea 100644
--- a/frontend/src/components/listing/ListingHeader.tsx
+++ b/frontend/src/components/listing/ListingHeader.tsx
@@ -109,7 +109,7 @@ const CloseButton = () => {
 
 const ListingHeader = (props: Props) => {
   return (
-    <div className="relative border-b p-4 mb-4">
+    <div className="relative p-4 mb-4">
       <div className="grid grid-cols-1 md:grid-cols-[1fr_auto] gap-4">
         <ListingTitle {...props} />
         <CloseButton />
diff --git a/frontend/src/components/listing/ListingImages.tsx b/frontend/src/components/listing/ListingImages.tsx
index 3fe5d576..6211e4a8 100644
--- a/frontend/src/components/listing/ListingImages.tsx
+++ b/frontend/src/components/listing/ListingImages.tsx
@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { FaCaretSquareDown, FaCaretSquareUp, FaTimes } from "react-icons/fa";
+import { FaTimes } from "react-icons/fa";
 
 import { components } from "gen/api";
 import { useAlertQueue } from "hooks/useAlertQueue";
@@ -27,7 +27,6 @@ const ListingImages = (props: Props) => {
     allArtifacts.filter((a) => a.artifact_type === "image"),
   );
   const [deletingIds, setDeletingIds] = useState<string[]>([]);
-  const [collapsed, setCollapsed] = useState<boolean>(true);
 
   const [showImageModal, setShowImageModal] = useState<number | null>(null);
 
@@ -55,65 +54,46 @@ const ListingImages = (props: Props) => {
     <div className="flex flex-col items-center justify-center relative">
       {images.length > 0 ? (
         <>
-          <Button
-            onClick={() => setCollapsed(!collapsed)}
-            variant="primary"
-            className="text-md p-4 w-full"
-          >
-            {collapsed ? (
-              <FaCaretSquareUp className="mr-2" />
-            ) : (
-              <FaCaretSquareDown className="mr-2" />
-            )}
-            Images
-          </Button>
-          {!collapsed && (
-            <>
-              <div className="grid gap-2 md:gap-4 mx-auto w-full grid-cols-1 lg:grid-cols-2 xl:grid-cols-3 mt-4">
-                {images.map((image, idx) => (
-                  <div
-                    key={image.artifact_id}
-                    className="bg-background relative p"
+          <div className="grid gap-2 md:gap-4 mx-auto w-full grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 mt-4">
+            {images.map((image, idx) => (
+              <div key={image.artifact_id} className="bg-background relative p">
+                <div className="bg-white rounded-lg w-full">
+                  <img
+                    src={image.urls.small ?? image.urls.large}
+                    alt={image.name}
+                    className="aspect-square cursor-pointer rounded-lg w-full"
+                    onClick={() => setShowImageModal(idx)}
+                  />
+                </div>
+                {edit && (
+                  <Button
+                    onClick={() => onDelete(image.artifact_id)}
+                    variant="destructive"
+                    className="absolute top-2 right-2 rounded-full"
+                    disabled={deletingIds.includes(image.artifact_id)}
                   >
-                    <div className="bg-white rounded-lg w-full">
-                      <img
-                        src={image.url}
-                        alt={image.name}
-                        className="aspect-square cursor-pointer rounded-lg"
-                        onClick={() => setShowImageModal(idx)}
-                      />
-                    </div>
-                    {edit && (
-                      <Button
-                        onClick={() => onDelete(image.artifact_id)}
-                        variant="destructive"
-                        className="absolute top-2 right-2 rounded-full"
-                        disabled={deletingIds.includes(image.artifact_id)}
-                      >
-                        <FaTimes />
-                      </Button>
-                    )}
-                  </div>
-                ))}
+                    <FaTimes />
+                  </Button>
+                )}
               </div>
-              {showImageModal !== null && (
-                <div
-                  className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50"
-                  onClick={() => setShowImageModal(null)}
-                >
-                  <div
-                    className="absolute bg-white rounded-lg p-4 max-w-4xl max-h-4xl m-4"
-                    onClick={(e) => e.stopPropagation()}
-                  >
-                    <img
-                      src={images[showImageModal].url}
-                      alt={images[showImageModal].name}
-                      className="max-h-full max-w-full"
-                    />
-                  </div>
-                </div>
-              )}
-            </>
+            ))}
+          </div>
+          {showImageModal !== null && (
+            <div
+              className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50"
+              onClick={() => setShowImageModal(null)}
+            >
+              <div
+                className="absolute bg-white rounded-lg p-4 max-w-4xl max-h-4xl m-4"
+                onClick={(e) => e.stopPropagation()}
+              >
+                <img
+                  src={images[showImageModal].urls.large}
+                  alt={images[showImageModal].name}
+                  className="max-h-full max-w-full"
+                />
+              </div>
+            </div>
           )}
         </>
       ) : (
@@ -123,10 +103,13 @@ const ListingImages = (props: Props) => {
       )}
       {edit && (
         <ListingFileUpload
-          accept={{
-            "image/*": [".jpg", ".jpeg", ".png", ".webp"],
+          description="Upload images"
+          dropzoneOptions={{
+            accept: {
+              "image/*": [".jpg", ".jpeg", ".png", ".webp"],
+            },
+            maxSize: 4 * 1024 * 1024,
           }}
-          maxSize={4 * 1024 * 1024}
           listingId={listingId}
           onUpload={(artifact) => {
             setImages([
diff --git a/frontend/src/components/listing/ListingMeshes.tsx b/frontend/src/components/listing/ListingMeshes.tsx
index 63aefc69..236f9f37 100644
--- a/frontend/src/components/listing/ListingMeshes.tsx
+++ b/frontend/src/components/listing/ListingMeshes.tsx
@@ -11,7 +11,7 @@ import MeshRenderer from "components/listing/MeshRenderer";
 import { Button } from "components/ui/Button/Button";
 import { Tooltip } from "components/ui/ToolTip";
 
-type MeshType = "stl" | "urdf";
+type MeshType = "obj";
 type AllArtifactsType =
   components["schemas"]["ListArtifactsResponse"]["artifacts"];
 type ArtifactType = AllArtifactsType[0];
@@ -25,8 +25,7 @@ interface Props {
 
 const getMeshType = (artifactType: ArtifactType["artifact_type"]): MeshType => {
   switch (artifactType) {
-    case "stl":
-    case "urdf":
+    case "obj":
       return artifactType;
     default:
       throw new Error(`Unknown artifact type: ${artifactType}`);
@@ -40,9 +39,7 @@ const ListingMeshes = (props: Props) => {
   const { addErrorAlert } = useAlertQueue();
 
   const [meshes, setMeshes] = useState<AllArtifactsType>(
-    allArtifacts
-      .filter((a) => ["stl", "urdf"].includes(a.artifact_type))
-      .sort((a) => (a.artifact_type === "urdf" ? -1 : 1)),
+    allArtifacts.filter((a) => ["obj"].includes(a.artifact_type)),
   );
   const [mesh, setMesh] = useState<MeshAndArtifactType | null>(null);
   const [deletingIds, setDeletingIds] = useState<string[]>([]);
@@ -131,7 +128,7 @@ const ListingMeshes = (props: Props) => {
                 ))}
               </div>
               <MeshRenderer
-                url={mesh[1].url}
+                url={mesh[1].urls.large}
                 name={mesh[1].name}
                 kind={mesh[0]}
                 edit={edit}
@@ -148,11 +145,15 @@ const ListingMeshes = (props: Props) => {
       )}
       {edit && (
         <ListingFileUpload
-          accept={{
-            "application/sla": [".stl"],
-            "application/xml": [".urdf"],
+          description="Upload meshes"
+          dropzoneOptions={{
+            accept: {
+              "application/sla": [".stl"],
+              "application/octet-stream": [".obj"],
+              "model/vnd.collada+xml": [".dae"],
+            },
+            maxSize: 4 * 1024 * 1024,
           }}
-          maxSize={4 * 1024 * 1024}
           listingId={listingId}
           onUpload={(artifact) => {
             setMeshes([
diff --git a/frontend/src/components/listing/ListingUrdf.tsx b/frontend/src/components/listing/ListingUrdf.tsx
new file mode 100644
index 00000000..817d8238
--- /dev/null
+++ b/frontend/src/components/listing/ListingUrdf.tsx
@@ -0,0 +1,299 @@
+import { useEffect, useState } from "react";
+
+import { components } from "gen/api";
+import { useAlertQueue } from "hooks/useAlertQueue";
+import { useAuthentication } from "hooks/useAuth";
+import { Paperclip } from "lucide-react";
+
+import RequireAuthentication from "components/auth/RequireAuthentication";
+import {
+  FileInput,
+  FileSubmitButton,
+  FileUploader,
+  FileUploaderContent,
+  FileUploaderItem,
+} from "components/listing/FileUpload";
+import { Button } from "components/ui/Button/Button";
+import Spinner from "components/ui/Spinner";
+
+type UrdfResponseType = components["schemas"]["UrdfResponse"];
+
+// TODO: Now that we are uploading the URDF as as TAR file, we need to change
+// this so that rather than looking for the unzipped URDF file and meshes,
+// it downloads the entire zipped and validated file.
+
+// interface UrdfModelProps {
+//   url: string;
+// }
+
+// const UrdfModel = ({ url }: UrdfModelProps) => {
+//   const ref = useRef<Group>();
+//   const geom = useLoader(URDFLoader, url);
+
+//   return (
+//     <group>
+//       <mesh castShadow receiveShadow position={[0, 0, 0]} rotation={[0, 0, 0]}>
+//         <primitive
+//           ref={ref}
+//           object={geom}
+//           position={[0, 0, 0]}
+//           dispose={null}
+//           castShadow
+//         />
+//       </mesh>
+//       <Plane receiveShadow rotation={[0, 0, 0]} args={[100, 100]}>
+//         <shadowMaterial opacity={0.25} />
+//       </Plane>
+//     </group>
+//   );
+// };
+
+interface Props {
+  listingId: string;
+  edit: boolean;
+}
+
+const ListingUrdf = (props: Props) => {
+  const { listingId, edit } = props;
+
+  const auth = useAuthentication();
+  const { addErrorAlert } = useAlertQueue();
+  const [urdf, setUrdf] = useState<UrdfResponseType | null>(null);
+  const [confirmDelete, setConfirmDelete] = useState(false);
+
+  const [files, setFiles] = useState<File[] | null>(null);
+  const [uploading, setUploading] = useState(false);
+  const [showUrdf, setShowUrdf] = useState(false);
+  const [clickedCopyButton, setClickedCopyButton] = useState(false);
+
+  useEffect(() => {
+    if (urdf !== null) {
+      return;
+    }
+
+    (async () => {
+      const { data, error } = await auth.client.GET("/urdf/info/{listing_id}", {
+        params: {
+          path: {
+            listing_id: listingId,
+          },
+        },
+      });
+
+      if (error) {
+        addErrorAlert(error);
+      } else {
+        setUrdf(data);
+      }
+    })();
+  }, [listingId, urdf]);
+
+  const onDelete = async () => {
+    if (urdf === null) {
+      return;
+    }
+
+    const { error } = await auth.client.DELETE("/urdf/delete/{listing_id}", {
+      params: {
+        path: {
+          listing_id: listingId,
+        },
+      },
+    });
+
+    if (error) {
+      addErrorAlert(error);
+    } else {
+      setUrdf(null);
+      setConfirmDelete(false);
+    }
+  };
+
+  const onUpload = async () => {
+    if (files === null) {
+      return;
+    }
+
+    if (files.length !== 1) {
+      addErrorAlert("Please upload a single file");
+      return;
+    }
+
+    setUploading(true);
+    const { data, error } = await auth.api.uploadUrdf(files[0], listingId);
+
+    if (error) {
+      addErrorAlert(error);
+    } else {
+      setUrdf(data);
+    }
+    setUploading(false);
+  };
+
+  const onClickCopyButton = async () => {
+    setClickedCopyButton(true);
+    const url = urdf?.urdf?.url;
+    if (url) {
+      navigator.clipboard.writeText(url);
+    }
+
+    setTimeout(() => {
+      setClickedCopyButton(false);
+    }, 1000);
+  };
+
+  return urdf !== null || edit ? (
+    <div className="flex flex-col space-y-2 w-full mt-4">
+      {urdf === null ? (
+        <div className="flex justify-center">
+          <Spinner />
+        </div>
+      ) : (
+        urdf.urdf !== null && (
+          <>
+            {showUrdf ? (
+              <>
+                <div className="flex justify-center">
+                  <Button
+                    onClick={() => setShowUrdf(false)}
+                    variant="secondary"
+                    className="rounded-full"
+                  >
+                    <code>hide urdf</code>
+                  </Button>
+                </div>
+                <RequireAuthentication onClosed={() => setShowUrdf(false)}>
+                  {/* <Canvas className="aspect-square rounded-lg">
+                  <PerspectiveCamera
+                    makeDefault
+                    fov={50}
+                    aspect={window.innerWidth / window.innerHeight}
+                    position={[1, 1, 0]}
+                    up={[0, 0, 1]}
+                    near={0.1}
+                    far={14}
+                  ></PerspectiveCamera>
+                  <directionalLight
+                    color={0xeb4634}
+                    position={[1, 0.75, 0.5]}
+                  />
+                  <directionalLight
+                    color={0xccccff}
+                    position={[-1, 0.75, -0.5]}
+                  />
+                  <OrbitControls zoomSpeed={0.2} />
+                  <Suspense fallback={<Loader />}>
+                    <Center>
+                      <UrdfModel url={urdf.urdf.url} />
+                    </Center>
+                  </Suspense>
+                </Canvas> */}
+                  <Button
+                    onClick={onClickCopyButton}
+                    variant="ghost"
+                    className="rounded-full"
+                    disabled={clickedCopyButton}
+                  >
+                    <code>{clickedCopyButton ? "copied!" : urdf.urdf.url}</code>
+                  </Button>
+                </RequireAuthentication>
+              </>
+            ) : (
+              <div className="flex justify-center">
+                <Button
+                  onClick={() => setShowUrdf(true)}
+                  variant="secondary"
+                  className="rounded-full"
+                >
+                  <code>show urdf</code>
+                </Button>
+              </div>
+            )}
+
+            {/* Delete button */}
+            {edit && (
+              <div className="flex flex-row gap-2 justify-center">
+                {confirmDelete ? (
+                  <>
+                    <Button
+                      onClick={onDelete}
+                      variant="destructive"
+                      className="rounded-full"
+                    >
+                      <code>confirm</code>
+                    </Button>
+                    <Button
+                      onClick={() => setConfirmDelete(false)}
+                      variant="secondary"
+                      className="rounded-full"
+                    >
+                      <code>cancel</code>
+                    </Button>
+                  </>
+                ) : (
+                  <Button
+                    onClick={() => setConfirmDelete(true)}
+                    variant="secondary"
+                    className="rounded-full"
+                  >
+                    <code>delete</code>
+                  </Button>
+                )}
+              </div>
+            )}
+          </>
+        )
+      )}
+
+      {/* Upload */}
+      {edit &&
+        (uploading ? (
+          <div className="flex justify-center">
+            <Spinner />
+          </div>
+        ) : (
+          <FileUploader
+            value={files}
+            onValueChange={setFiles}
+            dropzoneOptions={{
+              accept: {
+                "application/gzip": [".tar.gz", ".tgz"],
+                "application/zip": [".zip"],
+              },
+              maxSize: 25 * 1024 * 1024,
+              maxFiles: 1,
+            }}
+            className="relative bg-background mt-4 rounded-lg"
+          >
+            <FileInput>
+              <div className="flex justify-center w-full h-32">
+                <div className="align-middle h-full justify-center flex flex-col">
+                  <div className="text-center">Upload a new URDF</div>
+                  <div className="text-center">
+                    File extensions: .zip, .tgz, .tar.gz
+                  </div>
+                </div>
+              </div>
+            </FileInput>
+            <FileUploaderContent>
+              {files &&
+                files.length > 0 &&
+                files.map((file, index: number) => (
+                  <FileUploaderItem key={index} index={index}>
+                    <Paperclip className="h-4 w-4 stroke-current" />
+                    <span>{file.name}</span>
+                  </FileUploaderItem>
+                ))}
+            </FileUploaderContent>
+            {files && files.length > 0 && (
+              <FileSubmitButton onClick={onUpload}>
+                <span>Upload</span>
+              </FileSubmitButton>
+            )}
+          </FileUploader>
+        ))}
+    </div>
+  ) : null;
+};
+
+export default ListingUrdf;
diff --git a/frontend/src/components/listing/MeshRenderer.tsx b/frontend/src/components/listing/MeshRenderer.tsx
index abcd0b9d..260a9011 100644
--- a/frontend/src/components/listing/MeshRenderer.tsx
+++ b/frontend/src/components/listing/MeshRenderer.tsx
@@ -1,101 +1,40 @@
-/* eslint-disable-next-line @typescript-eslint/ban-ts-comment */
-// @ts-nocheck
-
-/* eslint-disable react/no-unknown-property */
 import { Suspense, useRef, useState } from "react";
 
-import {
-  Center,
-  OrbitControls,
-  PerspectiveCamera,
-  Plane,
-} from "@react-three/drei";
+import { Center, OrbitControls, PerspectiveCamera } from "@react-three/drei";
 import { Canvas, useLoader } from "@react-three/fiber";
 import { cx } from "class-variance-authority";
 import { Group } from "three";
-import { STLLoader } from "three/examples/jsm/loaders/STLLoader";
-import URDFLoader from "urdf-loader";
+import { OBJLoader } from "three/examples/jsm/loaders/OBJLoader";
 
 import Loader from "components/listing/Loader";
 import { Button } from "components/ui/Button/Button";
 
-type MeshType = "wireframe" | "basic";
-
-const MeshTypes: MeshType[] = ["wireframe", "basic"];
-
-const getMaterial = (meshType: MeshType) => {
-  switch (meshType) {
-    case "wireframe":
-      return <meshBasicMaterial attach="material" wireframe />;
-    case "basic":
-    default:
-      return (
-        <meshStandardMaterial
-          attach="material"
-          color="white"
-          roughness={0.5}
-          metalness={0.5}
-        />
-      );
-  }
-};
-
-interface UrdfModelProps {
+interface ObjModelProps {
   url: string;
-  meshType: MeshType;
 }
 
-const UrdfModel = ({ url, meshType }: UrdfModelProps) => {
-  const ref = useRef<Group>();
-  const geom = useLoader(URDFLoader, url);
+const ObjModel = ({ url }: ObjModelProps) => {
+  const groupRef = useRef<Group>(null);
+  const geom = useLoader(OBJLoader, url);
 
   return (
-    <group>
-      <mesh castShadow receiveShadow position={[0, 0, 0]} rotation={[0, 0, 0]}>
-        <primitive
-          ref={ref}
-          object={geom}
-          position={[0, 0, 0]}
-          dispose={null}
-          castShadow
-        />
-        {getMaterial(meshType)}
-      </mesh>
-      <Plane receiveShadow rotation={[0, 0, 0]} args={[100, 100]}>
-        <shadowMaterial opacity={0.25} />
-      </Plane>
+    // eslint-disable-next-line react/no-unknown-property
+    <group ref={groupRef} scale={[0.5, 0.5, 0.5]} position={[0, 0, 0]}>
+      {/* eslint-disable-next-line react/no-unknown-property */}
+      <primitive object={geom} />
     </group>
   );
 };
 
-interface StlModelProps {
-  url: string;
-  meshType: MeshType;
-}
-
-const StlModel = ({ url, meshType }: StlModelProps) => {
-  const geom = useLoader(STLLoader, url);
-
-  return (
-    <mesh scale={1.2} castShadow receiveShadow>
-      <primitive attach="geometry" object={geom}></primitive>
-      {getMaterial(meshType)}
-    </mesh>
-  );
-};
-
 interface ModelProps {
   url: string;
-  meshType: MeshType;
-  kind: "stl" | "urdf";
+  kind: "obj";
 }
 
-const Model = ({ url, meshType, kind }: ModelProps) => {
+const Model = ({ url, kind }: ModelProps) => {
   switch (kind) {
-    case "stl":
-      return <StlModel url={url} meshType={meshType} />;
-    case "urdf":
-      return <UrdfModel url={url} meshType={meshType} />;
+    case "obj":
+      return <ObjModel url={url} />;
     default:
       return null;
   }
@@ -107,11 +46,10 @@ interface Props {
   edit?: boolean;
   onDelete?: () => void;
   disabled?: boolean;
-  kind: "stl" | "urdf";
+  kind: "obj";
 }
 
 const MeshRenderer = ({ url, name, edit, onDelete, disabled, kind }: Props) => {
-  const [meshType, setMeshType] = useState<MeshType>("basic");
   const [clickedCopyButton, setClickedCopyButton] = useState(false);
   const [confirmDelete, setConfirmDelete] = useState(false);
 
@@ -133,12 +71,14 @@ const MeshRenderer = ({ url, name, edit, onDelete, disabled, kind }: Props) => {
           near={0.1}
           far={14}
         ></PerspectiveCamera>
+        {/* eslint-disable-next-line react/no-unknown-property */}
         <directionalLight color={0xeb4634} position={[1, 0.75, 0.5]} />
+        {/* eslint-disable-next-line react/no-unknown-property */}
         <directionalLight color={0xccccff} position={[-1, 0.75, -0.5]} />
         <OrbitControls zoomSpeed={0.2} />
         <Suspense fallback={<Loader />}>
           <Center>
-            <Model url={url} meshType={meshType} kind={kind} />
+            <Model url={url} kind={kind} />
           </Center>
         </Suspense>
       </Canvas>
@@ -147,20 +87,9 @@ const MeshRenderer = ({ url, name, edit, onDelete, disabled, kind }: Props) => {
       <div
         className={cx(
           "grid grid-cols-1 gap-2 md:gap-4 mx-auto w-full",
-          edit ? "md:grid-cols-3" : "md:grid-cols-2",
+          edit ? "md:grid-cols-2" : "md:grid-cols-1",
         )}
       >
-        <Button
-          onClick={() => {
-            setMeshType(
-              MeshTypes[(MeshTypes.indexOf(meshType) + 1) % MeshTypes.length],
-            );
-          }}
-          variant="secondary"
-          className="rounded-full"
-        >
-          <code>{meshType}</code>
-        </Button>
         <div className="group relative">
           <Button
             onClick={() => {
diff --git a/frontend/src/components/listings/ListingGridCard.tsx b/frontend/src/components/listings/ListingGridCard.tsx
index 75b8e7b1..811bc3a7 100644
--- a/frontend/src/components/listings/ListingGridCard.tsx
+++ b/frontend/src/components/listings/ListingGridCard.tsx
@@ -5,8 +5,7 @@ import clsx from "clsx";
 import { paths } from "gen/api";
 
 import ImagePlaceholder from "components/ImagePlaceholder";
-import { RenderDescription } from "components/listing/ListingDescription";
-import { Card, CardContent, CardHeader, CardTitle } from "components/ui/Card";
+import { Card, CardHeader, CardTitle } from "components/ui/Card";
 
 type ListingInfo =
   paths["/listings/batch"]["get"]["responses"][200]["content"]["application/json"]["listings"];
@@ -56,15 +55,6 @@ const ListingGridCard = (props: Props) => {
             )}
           </CardTitle>
         </CardHeader>
-        <CardContent className="text-gray-500 dark:text-gray-300 max-h-32 overflow-hidden">
-          {listing ? (
-            listing?.description && (
-              <RenderDescription description={listing?.description} />
-            )
-          ) : (
-            <div className="animate-pulse bg-gray-200 dark:bg-gray-700 h-6 w-full"></div>
-          )}
-        </CardContent>
       </div>
     </Card>
   );
diff --git a/frontend/src/components/ui/Toast.tsx b/frontend/src/components/ui/Toast.tsx
index ab095902..c993f3d2 100644
--- a/frontend/src/components/ui/Toast.tsx
+++ b/frontend/src/components/ui/Toast.tsx
@@ -57,13 +57,13 @@ const Toast = (props: Props) => {
 
   return (
     <div
-      className="flex items-center w-full max-w-xs p-4 text-gray-500 bg-white rounded-lg shadow dark:text-gray-300 dark:bg-gray-800"
+      className="flex items-center w-full p-4 text-gray-500 bg-white rounded-lg shadow dark:text-gray-300 dark:bg-gray-800"
       role="alert"
     >
       <div className="inline-flex items-center justify-center flex-shrink-0 w-8 h-8 text-blue-500 bg-blue-100 rounded-lg dark:bg-blue-800 dark:text-blue-200">
         <ToastIcon kind={kind} />
       </div>
-      <div className="ms-3 text-sm font-normal">{message}</div>
+      <div className="ms-3 text-sm font-normal max-w-xs">{message}</div>
       <Button
         variant="ghost"
         className="ml-4 hover:bg-gray-200"
diff --git a/frontend/src/gen/api.ts b/frontend/src/gen/api.ts
index 64d5368a..a30bbbef 100644
--- a/frontend/src/gen/api.ts
+++ b/frontend/src/gen/api.ts
@@ -424,7 +424,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/artifacts/upload": {
+    "/artifacts/upload/{listing_id}": {
         parameters: {
             query?: never;
             header?: never;
@@ -434,7 +434,7 @@ export interface paths {
         get?: never;
         put?: never;
         /** Upload */
-        post: operations["upload_artifacts_upload_post"];
+        post: operations["upload_artifacts_upload__listing_id__post"];
         delete?: never;
         options?: never;
         head?: never;
@@ -535,21 +535,85 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/urdf/info/{listing_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Urdf */
+        get: operations["get_urdf_urdf_info__listing_id__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/urdf/upload/{listing_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Set Urdf */
+        post: operations["set_urdf_urdf_upload__listing_id__post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/urdf/delete/{listing_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Delete Urdf */
+        delete: operations["delete_urdf_urdf_delete__listing_id__delete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
+        /** ArtifactUrls */
+        ArtifactUrls: {
+            /** Small */
+            small?: string | null;
+            /** Large */
+            large: string;
+        };
         /** AuthResponse */
         AuthResponse: {
             /** Api Key */
             api_key: string;
         };
-        /** Body_upload_artifacts_upload_post */
-        Body_upload_artifacts_upload_post: {
+        /** Body_set_urdf_urdf_upload__listing_id__post */
+        Body_set_urdf_urdf_upload__listing_id__post: {
+            /**
+             * File
+             * Format: binary
+             */
+            file: string;
+        };
+        /** Body_upload_artifacts_upload__listing_id__post */
+        Body_upload_artifacts_upload__listing_id__post: {
             /** Files */
             files: string[];
-            /** Metadata */
-            metadata: string;
         };
         /** ClientIdResponse */
         ClientIdResponse: {
@@ -596,8 +660,8 @@ export interface components {
             child_ids: string[];
             /** Tags */
             tags: string[];
-            /** Owner Is User */
-            owner_is_user: boolean;
+            /** Can Edit */
+            can_edit: boolean;
         };
         /** GetTokenResponse */
         GetTokenResponse: {
@@ -634,17 +698,13 @@ export interface components {
             listing_id: string;
             /** Name */
             name: string;
-            /**
-             * Artifact Type
-             * @enum {string}
-             */
-            artifact_type: "image" | "urdf" | "mjcf" | "stl";
+            /** Artifact Type */
+            artifact_type: "image" | ("urdf" | "mjcf") | ("stl" | "obj" | "dae" | "ply") | ("tgz" | "zip");
             /** Description */
             description: string | null;
             /** Timestamp */
             timestamp: number;
-            /** Url */
-            url: string;
+            urls: components["schemas"]["ArtifactUrls"];
             /** Is New */
             is_new?: boolean | null;
         };
@@ -788,6 +848,19 @@ export interface components {
             /** Artifacts */
             artifacts: components["schemas"]["ListArtifactsItem"][];
         };
+        /** UrdfInfo */
+        UrdfInfo: {
+            /** Artifact Id */
+            artifact_id: string;
+            /** Url */
+            url: string;
+        };
+        /** UrdfResponse */
+        UrdfResponse: {
+            urdf: components["schemas"]["UrdfInfo"] | null;
+            /** Listing Id */
+            listing_id: string;
+        };
         /** UserInfoResponseItem */
         UserInfoResponseItem: {
             /** Id */
@@ -1502,7 +1575,7 @@ export interface operations {
             };
             header?: never;
             path: {
-                artifact_type: "image" | "urdf" | "mjcf" | "stl";
+                artifact_type: "image" | ("urdf" | "mjcf") | ("stl" | "obj" | "dae" | "ply") | ("tgz" | "zip");
                 listing_id: string;
                 name: string;
             };
@@ -1561,16 +1634,18 @@ export interface operations {
             };
         };
     };
-    upload_artifacts_upload_post: {
+    upload_artifacts_upload__listing_id__post: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                listing_id: string;
+            };
             cookie?: never;
         };
         requestBody: {
             content: {
-                "multipart/form-data": components["schemas"]["Body_upload_artifacts_upload_post"];
+                "multipart/form-data": components["schemas"]["Body_upload_artifacts_upload__listing_id__post"];
             };
         };
         responses: {
@@ -1755,4 +1830,101 @@ export interface operations {
             };
         };
     };
+    get_urdf_urdf_info__listing_id__get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                listing_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UrdfResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    set_urdf_urdf_upload__listing_id__post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                listing_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "multipart/form-data": components["schemas"]["Body_set_urdf_urdf_upload__listing_id__post"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UrdfResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    delete_urdf_urdf_delete__listing_id__delete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                listing_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UrdfResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
 }
diff --git a/frontend/src/hooks/api.tsx b/frontend/src/hooks/api.tsx
index f4d5ff62..95acfec2 100644
--- a/frontend/src/hooks/api.tsx
+++ b/frontend/src/hooks/api.tsx
@@ -8,21 +8,37 @@ export default class api {
     this.client = client;
   }
 
-  public async upload(
-    files: File[],
-    request: {
-      listing_id: string;
-    },
-  ) {
-    return await this.client.POST("/artifacts/upload", {
+  public async upload(files: File[], listing_id: string) {
+    return await this.client.POST("/artifacts/upload/{listing_id}", {
       body: {
         files: [],
-        metadata: "image",
+      },
+      params: {
+        path: {
+          listing_id,
+        },
       },
       bodySerializer() {
         const fd = new FormData();
         files.forEach((file) => fd.append("files", file));
-        fd.append("metadata", JSON.stringify(request));
+        return fd;
+      },
+    });
+  }
+
+  public async uploadUrdf(file: File, listing_id: string) {
+    return await this.client.POST("/urdf/upload/{listing_id}", {
+      body: {
+        file: "",
+      },
+      params: {
+        path: {
+          listing_id,
+        },
+      },
+      bodySerializer() {
+        const fd = new FormData();
+        fd.append("file", file);
         return fd;
       },
     });
diff --git a/frontend/src/pages/Browse.tsx b/frontend/src/pages/Browse.tsx
index a40f02df..5682597f 100644
--- a/frontend/src/pages/Browse.tsx
+++ b/frontend/src/pages/Browse.tsx
@@ -7,6 +7,7 @@ import { useAlertQueue } from "hooks/useAlertQueue";
 import { useAuthentication } from "hooks/useAuth";
 
 import ListingGrid from "components/listings/ListingGrid";
+import { Button } from "components/ui/Button/Button";
 import { Input } from "components/ui/Input/Input";
 
 const Browse = () => {
@@ -85,6 +86,13 @@ const Browse = () => {
               </div>
             )}
           </div>
+          <Button
+            onClick={() => navigate(`/create`)}
+            variant="secondary"
+            size="lg"
+          >
+            Create
+          </Button>
         </div>
 
         {hasButton && (
diff --git a/frontend/src/pages/ListingDetails.tsx b/frontend/src/pages/ListingDetails.tsx
index 869bce4c..f82e4809 100644
--- a/frontend/src/pages/ListingDetails.tsx
+++ b/frontend/src/pages/ListingDetails.tsx
@@ -21,14 +21,14 @@ const RenderListing = (props: RenderListingProps) => {
   const { listing } = props;
 
   return (
-    <div className="container mx-auto max-w-4xl shadow-md rounded-lg bg-white dark:bg-gray-800 dark:text-white border bg-card text-card-foreground relative">
+    <div className="container mx-auto max-w-6xl">
       <ListingHeader
         listingId={listing.id}
         title={listing.name}
-        edit={listing.owner_is_user}
+        edit={listing.can_edit}
       />
       <ListingBody listing={listing} />
-      <ListingFooter listingId={listing.id} edit={listing.owner_is_user} />
+      <ListingFooter listingId={listing.id} edit={listing.can_edit} />
     </div>
   );
 };
diff --git a/store/app/crud/artifacts.py b/store/app/crud/artifacts.py
index cd85dae1..e5bec83e 100644
--- a/store/app/crud/artifacts.py
+++ b/store/app/crud/artifacts.py
@@ -3,14 +3,16 @@
 import asyncio
 import io
 import logging
-from typing import Any, BinaryIO, Literal
+from typing import IO, Any, Literal
 from xml.etree import ElementTree as ET
 
+import trimesh
+from boto3.dynamodb.conditions import ComparisonCondition
+from fastapi import UploadFile
 from PIL import Image
-from stl import Mode as STLMode, mesh as stlmesh
 
 from store.app.crud.base import BaseCrud, ItemNotFoundError
-from store.app.errors import BadArtifactError, NotAuthorizedError
+from store.app.errors import BadArtifactError
 from store.app.model import (
     Artifact,
     ArtifactSize,
@@ -31,7 +33,7 @@ class ArtifactsCrud(BaseCrud):
     def get_gsis(cls) -> set[str]:
         return super().get_gsis().union({"user_id", "listing_id", "name"})
 
-    async def _crop_image(self, image: Image.Image, size: tuple[int, int]) -> io.BytesIO:
+    async def _crop_image(self, image: Image.Image, size: tuple[int, int]) -> IO[bytes]:
         # Simply squashes the image to the desired size.
         # image_resized = image.resize(size, resample=Image.Resampling.BICUBIC)
         # Finds a bounding box of the image and crops it to the desired size.
@@ -67,15 +69,12 @@ async def _upload_cropped_image(self, image: Image.Image, artifact: Artifact, si
     async def _upload_image(
         self,
         name: str,
-        file: io.BytesIO | BinaryIO,
+        file: UploadFile,
         listing: Listing,
-        user_id: str,
         description: str | None = None,
     ) -> Artifact:
-        if listing.user_id != user_id:
-            raise NotAuthorizedError("User does not have permission to upload artifacts to this listing")
         artifact = Artifact.create(
-            user_id=user_id,
+            user_id=listing.user_id,
             listing_id=listing.id,
             name=name,
             artifact_type="image",
@@ -83,7 +82,7 @@ async def _upload_image(
             description=description,
         )
 
-        image = Image.open(file)
+        image = Image.open(io.BytesIO(await file.read()))
 
         await asyncio.gather(
             *(self._upload_cropped_image(image=image, artifact=artifact, size=size) for size in SizeMapping.keys()),
@@ -94,39 +93,32 @@ async def _upload_image(
     async def get_raw_artifact(self, artifact_id: str) -> Artifact | None:
         return await self._get_item(artifact_id, Artifact)
 
-    async def _upload_stl(
+    async def _upload_mesh(
         self,
         name: str,
-        file: io.BytesIO | BinaryIO,
+        file: UploadFile,
         listing: Listing,
-        user_id: str,
+        artifact_type: Literal["stl", "obj", "ply", "dae"],
         description: str | None = None,
     ) -> Artifact:
-        if listing.user_id != user_id:
-            raise NotAuthorizedError("User does not have permission to upload artifacts to this listing")
-
         # Converts the mesh to a binary STL file.
-        mesh = stlmesh.Mesh.from_file(None, calculate_normals=True, fh=file)
+        file_data = await file.read()
+
+        tmesh = trimesh.load(io.BytesIO(file_data), file_type=artifact_type)
+        if not isinstance(tmesh, trimesh.Trimesh):
+            raise BadArtifactError(f"Invalid mesh file: {name}")
+
         out_file = io.BytesIO()
-        mesh.save(name, fh=out_file, mode=STLMode.BINARY)
+        tmesh.export(out_file, file_type="obj")
         out_file.seek(0)
 
+        # Replaces name suffix.
+        name = f"{name.rsplit('.', 1)[0]}.obj"
+
         # Saves the artifact to S3.
-        content_type = get_content_type("stl")
-        artifact = Artifact.create(
-            user_id=user_id,
-            listing_id=listing.id,
-            name=name,
-            artifact_type="stl",
-            description=description,
-        )
-        await asyncio.gather(
-            self._upload_to_s3(out_file, name, get_artifact_name(artifact=artifact), content_type),
-            self._add_item(artifact),
-        )
+        artifact = await self._upload_and_store(name, out_file, listing, "obj", description)
 
         # Closes the file handlers when done.
-        file.close()
         out_file.close()
 
         return artifact
@@ -134,18 +126,14 @@ async def _upload_stl(
     async def _upload_xml(
         self,
         name: str,
-        file: io.BytesIO | BinaryIO,
+        file: UploadFile,
         listing: Listing,
-        user_id: str,
         artifact_type: Literal["urdf", "mjcf"],
         description: str | None = None,
     ) -> Artifact:
-        if listing.user_id != user_id:
-            raise NotAuthorizedError("User does not have permission to upload artifacts to this listing")
-
         # Standardizes the XML file.
         try:
-            tree = ET.parse(file)
+            tree = ET.parse(io.BytesIO(await file.read()))
         except Exception:
             raise BadArtifactError("Invalid XML file")
 
@@ -157,16 +145,26 @@ async def _upload_xml(
         out_file.seek(0)
 
         # Saves the artifact to S3.
+        return await self._upload_and_store(name, out_file, listing, artifact_type, description)
+
+    async def _upload_and_store(
+        self,
+        name: str,
+        file: IO[bytes],
+        listing: Listing,
+        artifact_type: ArtifactType,
+        description: str | None = None,
+    ) -> Artifact:
         content_type = get_content_type(artifact_type)
         artifact = Artifact.create(
-            user_id=user_id,
+            user_id=listing.user_id,
             listing_id=listing.id,
             name=name,
             artifact_type=artifact_type,
             description=description,
         )
         await asyncio.gather(
-            self._upload_to_s3(out_file, name, get_artifact_name(artifact=artifact), content_type),
+            self._upload_to_s3(file, name, get_artifact_name(artifact=artifact), content_type),
             self._add_item(artifact),
         )
         return artifact
@@ -174,9 +172,8 @@ async def _upload_xml(
     async def upload_artifact(
         self,
         name: str,
-        file: io.BytesIO | BinaryIO,
+        file: UploadFile,
         listing: Listing,
-        user_id: str,
         artifact_type: ArtifactType,
         description: str | None = None,
     ) -> tuple[Artifact, bool]:
@@ -188,43 +185,44 @@ async def upload_artifact(
 
         match artifact_type:
             case "image":
-                return await self._upload_image(name, file, listing, user_id, description), True
-            case "stl":
-                return await self._upload_stl(name, file, listing, user_id, description), True
+                return await self._upload_image(name, file, listing, description), True
+            case "stl" | "obj" | "ply" | "dae":
+                return await self._upload_mesh(name, file, listing, artifact_type, description), True
             case "urdf" | "mjcf":
-                return await self._upload_xml(name, file, listing, user_id, artifact_type, description), True
+                return await self._upload_xml(name, file, listing, artifact_type, description), True
             case _:
                 raise BadArtifactError(f"Invalid artifact type: {artifact_type}")
 
-    async def _remove_image(self, artifact: Artifact, user_id: str) -> None:
-        if artifact.user_id != user_id:
-            raise NotAuthorizedError("User does not have permission to delete this image")
+    async def _remove_image(self, artifact: Artifact) -> None:
         await asyncio.gather(
             *(self._delete_from_s3(get_artifact_name(artifact=artifact, size=size)) for size in SizeMapping.keys()),
             self._delete_item(artifact),
         )
 
-    async def _remove_raw_artifact(
-        self,
-        artifact: Artifact,
-        user_id: str,
-    ) -> None:
-        if artifact.user_id != user_id:
-            raise NotAuthorizedError("User does not have permission to delete this artifact")
+    async def _remove_raw_artifact(self, artifact: Artifact) -> None:
         await asyncio.gather(
             self._delete_from_s3(get_artifact_name(artifact=artifact)),
             self._delete_item(artifact),
         )
 
-    async def remove_artifact(self, artifact: Artifact, user_id: str) -> None:
+    async def remove_artifact(self, artifact: Artifact) -> None:
         match artifact.artifact_type:
             case "image":
-                await self._remove_image(artifact, user_id)
+                await self._remove_image(artifact)
             case _:
-                await self._remove_raw_artifact(artifact, user_id)
+                await self._remove_raw_artifact(artifact)
 
-    async def get_listing_artifacts(self, listing_id: str) -> list[Artifact]:
-        artifacts = await self._get_items_from_secondary_index("listing_id", listing_id, Artifact)
+    async def get_listing_artifacts(
+        self,
+        listing_id: str,
+        additional_filter_expression: ComparisonCondition | None = None,
+    ) -> list[Artifact]:
+        artifacts = await self._get_items_from_secondary_index(
+            "listing_id",
+            listing_id,
+            Artifact,
+            additional_filter_expression=additional_filter_expression,
+        )
         return sorted(artifacts, key=lambda a: a.timestamp)
 
     async def get_listings_artifacts(self, listing_ids: list[str]) -> list[list[Artifact]]:
diff --git a/store/app/crud/base.py b/store/app/crud/base.py
index 89aac3e4..acf99ddf 100644
--- a/store/app/crud/base.py
+++ b/store/app/crud/base.py
@@ -1,13 +1,12 @@
 """Defines the base CRUD interface."""
 
 import asyncio
-import io
 import itertools
 import logging
 from typing import (
+    IO,
     Any,
     AsyncContextManager,
-    BinaryIO,
     Callable,
     Literal,
     Self,
@@ -16,7 +15,7 @@
 )
 
 import aioboto3
-from boto3.dynamodb.conditions import Attr, Key
+from boto3.dynamodb.conditions import Attr, ComparisonCondition, Key
 from botocore.exceptions import ClientError
 from types_aiobotocore_dynamodb.service_resource import DynamoDBServiceResource
 from types_aiobotocore_s3.service_resource import S3ServiceResource
@@ -265,12 +264,16 @@ async def _get_items_from_secondary_index(
         secondary_index_name: str,
         secondary_index_value: str,
         item_class: type[T],
+        additional_filter_expression: ComparisonCondition | None = None,
     ) -> list[T]:
+        filter_expression: ComparisonCondition = Key("type").eq(item_class.__name__)
+        if additional_filter_expression is not None:
+            filter_expression &= additional_filter_expression
         table = await self.db.Table(TABLE_NAME)
         item_dict = await table.query(
             IndexName=self.get_gsi_index_name(secondary_index_name),
             KeyConditionExpression=Key(secondary_index_name).eq(secondary_index_value),
-            FilterExpression=Key("type").eq(item_class.__name__),
+            FilterExpression=filter_expression,
         )
         items = item_dict["Items"]
         return [self._validate_item(item, item_class) for item in items]
@@ -360,7 +363,7 @@ async def _update_item(self, item_id: str, item_class: type[T], new_values: dict
             AttributeUpdates={k: {"Value": v, "Action": "PUT"} for k, v in new_values.items() if k != "id"},
         )
 
-    async def _upload_to_s3(self, data: io.BytesIO | BinaryIO, name: str, filename: str, content_type: str) -> None:
+    async def _upload_to_s3(self, data: IO[bytes], name: str, filename: str, content_type: str) -> None:
         """Uploads some data to S3.
 
         Args:
@@ -401,6 +404,7 @@ async def _create_s3_bucket(self) -> None:
     async def _delete_s3_bucket(self) -> None:
         """Deletes an S3 bucket."""
         bucket = await self.s3.Bucket(settings.s3.bucket)
+        logger.info("Deleting bucket %s", settings.s3.bucket)
         async for obj in bucket.objects.all():
             await obj.delete()
         await bucket.delete()
diff --git a/store/app/crud/listings.py b/store/app/crud/listings.py
index 14c558a6..3d03dd80 100644
--- a/store/app/crud/listings.py
+++ b/store/app/crud/listings.py
@@ -43,7 +43,7 @@ async def add_listing(self, listing: Listing) -> None:
 
     async def _delete_listing_artifacts(self, listing: Listing) -> None:
         artifacts = await self.get_listing_artifacts(listing.id)
-        await asyncio.gather(*[self.remove_artifact(artifact, listing.user_id) for artifact in artifacts])
+        await asyncio.gather(*[self.remove_artifact(artifact) for artifact in artifacts])
 
     async def _delete_listing_tags(self, listing_id: str) -> None:
         listing_tags = await self._get_items_from_secondary_index("listing_id", listing_id, ListingTag)
@@ -51,11 +51,13 @@ async def _delete_listing_tags(self, listing_id: str) -> None:
 
     async def delete_listing(self, listing: Listing) -> None:
         await asyncio.gather(
-            self._delete_item(listing),
             self._delete_listing_artifacts(listing),
             self._delete_listing_tags(listing.id),
         )
 
+        # Only delete the listing after all artifacts have been removed.
+        await self._delete_item(listing)
+
     async def edit_listing(
         self,
         listing_id: str,
diff --git a/store/app/crud/urdf.py b/store/app/crud/urdf.py
new file mode 100644
index 00000000..f0e961e0
--- /dev/null
+++ b/store/app/crud/urdf.py
@@ -0,0 +1,146 @@
+"""Defines CRUD interface for handling user-uploaded URDFs.
+
+This simply sits on top of the ArtifactsCrud and provides a more specific
+interface for handling URDFs.
+"""
+
+import asyncio
+import io
+import logging
+import tarfile
+import zipfile
+from pathlib import Path
+from typing import IO, Iterator
+from xml.etree import ElementTree as ET
+
+import trimesh
+from boto3.dynamodb.conditions import Attr
+from fastapi import UploadFile
+
+from store.app.crud.artifacts import ArtifactsCrud
+from store.app.errors import BadArtifactError
+from store.app.model import Artifact, CompressedArtifactType, Listing
+from store.utils import save_xml
+
+logger = logging.getLogger(__name__)
+
+URDF_PACKAGE_NAME = "droid.tgz"
+
+
+def iter_components(file: IO[bytes], compression_type: CompressedArtifactType) -> Iterator[tuple[str, IO[bytes]]]:
+    """Iterates over the components of a tar file.
+
+    Args:
+        file: The tar file to iterate over.
+        compression_type: The type of compression used for the file.
+
+    Yields:
+        A tuple containing the name of the component and its contents.
+    """
+    match compression_type:
+        case "zip":
+            with zipfile.ZipFile(file) as zipf:
+                for name in zipf.namelist():
+                    # Fix for MacOS.
+                    if name.startswith("__MACOS"):
+                        continue
+                    with zipf.open(name) as zipdata:
+                        yield name, zipdata
+
+        case "tgz":
+            with tarfile.open(fileobj=file, mode="r:gz") as tar:
+                for member in tar.getmembers():
+                    if member.isfile() and (tardata := tar.extractfile(member)) is not None:
+                        with tardata:
+                            yield member.name, tardata
+
+        case _:
+            raise ValueError(f"Unknown compression type: {compression_type}")
+
+
+class UrdfCrud(ArtifactsCrud):
+    async def set_urdf(
+        self,
+        file: UploadFile,
+        listing: Listing,
+        compression_type: CompressedArtifactType,
+        description: str | None = None,
+    ) -> Artifact:
+        # Unpacks the TAR file, getting meshes and URDFs.
+        urdf: tuple[str, ET.ElementTree] | None = None
+        meshes: list[tuple[str, trimesh.Trimesh]] = []
+
+        compressed_data = await file.read()
+        for name, data in iter_components(io.BytesIO(compressed_data), compression_type):
+            suffix = name.lower().split(".")[-1]
+
+            if suffix == "urdf":
+                if urdf is not None:
+                    raise BadArtifactError("Multiple URDF files found in TAR.")
+                try:
+                    urdf_tree = ET.parse(io.BytesIO(data.read()))
+                except Exception:
+                    raise BadArtifactError("Invalid XML file")
+                urdf = name, urdf_tree
+
+            elif suffix in ("stl", "ply", "obj", "dae"):
+                try:
+                    tmesh = trimesh.load(data, file_type=suffix)
+                    assert isinstance(tmesh, trimesh.Trimesh)
+                except Exception:
+                    print(data.read())
+                    raise BadArtifactError(f"Invalid mesh file: {name}")
+                meshes.append((name, tmesh))
+
+            else:
+                raise BadArtifactError(f"Unknown file type: {name}")
+
+        if urdf is None:
+            raise BadArtifactError("No URDF file found in TAR.")
+        urdf_name, urdf_tree = urdf
+
+        # Checks that all of the mesh files are referenced.
+        mesh_names = {Path(name) for name, _ in meshes}
+        for mesh in urdf_tree.iter("mesh"):
+            if (filename := mesh.get("filename")) is None:
+                raise BadArtifactError("Mesh element missing filename attribute.")
+            filepath = Path(filename).relative_to(".")
+            if filepath not in mesh_names:
+                print(mesh_names)
+                raise BadArtifactError(f"Mesh referenced in URDF was not uploaded: {filepath}")
+            mesh_names.remove(filepath)
+            mesh.set("filename", str(filepath.with_suffix(".obj")))
+        if mesh_names:
+            raise BadArtifactError(f"Mesh files uploaded were not referenced: {mesh_names}")
+
+        # Saves everything to a new TAR file, using OBJ files for meshes.
+        tgz_out_file = io.BytesIO()
+        with tarfile.open(fileobj=tgz_out_file, mode="w:gz") as tar:
+            for name, tmesh in meshes:
+                out_file = io.BytesIO()
+                tmesh.export(out_file, file_type="obj")
+                info = tarfile.TarInfo(name)
+                info.size = out_file.tell()
+                out_file.seek(0)
+                tar.addfile(info, out_file)
+            urdf_out_file = io.BytesIO()
+            save_xml(urdf_out_file, urdf_tree)
+            urdf_out_file.seek(0)
+            info = tarfile.TarInfo(urdf_name)
+            info.size = len(urdf_out_file.getbuffer())
+            tar.addfile(info, urdf_out_file)
+
+        # Saves the TAR file to S3.
+        tgz_out_file.seek(0)
+        return await self._upload_and_store(URDF_PACKAGE_NAME, tgz_out_file, listing, "tgz", description)
+
+    async def get_urdf(self, listing_id: str) -> Artifact | None:
+        artifacts = await self.get_listing_artifacts(
+            listing_id=listing_id,
+            additional_filter_expression=Attr("name").eq(URDF_PACKAGE_NAME),
+        )
+        # If we ever end up in a situation where there are more than one URDFs,
+        # we have a problem and need to delete the extra ones.
+        if len(artifacts) > 2:
+            await asyncio.gather(*(self.remove_artifact(artifact) for artifact in artifacts[1:]))
+        return artifacts[0] if artifacts else None
diff --git a/store/app/db.py b/store/app/db.py
index 060b3608..e47d3f15 100644
--- a/store/app/db.py
+++ b/store/app/db.py
@@ -8,10 +8,12 @@
 from store.app.crud.artifacts import ArtifactsCrud
 from store.app.crud.base import TABLE_NAME, BaseCrud
 from store.app.crud.listings import ListingsCrud
+from store.app.crud.urdf import UrdfCrud
 from store.app.crud.users import UserCrud
 
 
 class Crud(
+    UrdfCrud,
     UserCrud,
     ListingsCrud,
     ArtifactsCrud,
diff --git a/store/app/main.py b/store/app/main.py
index 4e749d5d..876d6d47 100644
--- a/store/app/main.py
+++ b/store/app/main.py
@@ -20,6 +20,7 @@
 from store.app.routers.artifacts import artifacts_router
 from store.app.routers.email_signup import email_router
 from store.app.routers.listings import listings_router
+from store.app.routers.urdf import urdf_router
 from store.app.routers.users import users_router
 from store.settings import settings
 
@@ -94,6 +95,7 @@ async def not_authorized_exception_handler(request: Request, exc: NotAuthorizedE
 
 @app.exception_handler(BadArtifactError)
 async def bad_artifact_exception_handler(request: Request, exc: BadArtifactError) -> JSONResponse:
+    print("error:", exc)
     return JSONResponse(
         status_code=status.HTTP_400_BAD_REQUEST,
         content={"message": f"Bad artifact: {exc}", "detail": str(exc)},
@@ -109,6 +111,7 @@ async def read_root() -> bool:
 app.include_router(listings_router, prefix="/listings", tags=["listings"])
 app.include_router(artifacts_router, prefix="/artifacts", tags=["artifacts"])
 app.include_router(email_router, prefix="/email", tags=["email"])
+app.include_router(urdf_router, prefix="/urdf", tags=["urdf"])
 
 # For running with debugger
 if __name__ == "__main__":
diff --git a/store/app/model.py b/store/app/model.py
index 8e65d13d..b3cbd4a5 100644
--- a/store/app/model.py
+++ b/store/app/model.py
@@ -7,7 +7,7 @@
 
 import time
 from datetime import datetime, timedelta
-from typing import Literal, Self
+from typing import Literal, Self, cast, get_args
 
 from pydantic import BaseModel
 
@@ -148,7 +148,12 @@ def create(cls, user_id: str, source: APIKeySource, permissions: APIKeyPermissio
 
 
 ArtifactSize = Literal["small", "large"]
-ArtifactType = Literal["image", "urdf", "mjcf", "stl"]
+
+ImageArtifactType = Literal["image"]
+XMLArtifactType = Literal["urdf", "mjcf"]
+MeshArtifactType = Literal["stl", "obj", "dae", "ply"]
+CompressedArtifactType = Literal["tgz", "zip"]
+ArtifactType = ImageArtifactType | XMLArtifactType | MeshArtifactType | CompressedArtifactType
 
 UPLOAD_CONTENT_TYPE_OPTIONS: dict[ArtifactType, set[str]] = {
     # Image
@@ -156,8 +161,19 @@ def create(cls, user_id: str, source: APIKeySource, permissions: APIKeyPermissio
     # XML
     "urdf": {"application/octet-stream", "text/xml", "application/xml"},
     "mjcf": {"application/octet-stream", "text/xml", "application/xml"},
-    # Binary or text
+    # Meshes
     "stl": {"application/octet-stream", "text/plain"},
+    "obj": {"application/octet-stream", "text/plain"},
+    "dae": {"application/octet-stream", "text/plain"},
+    "ply": {"application/octet-stream", "text/plain"},
+    # Compressed
+    "tgz": {
+        "application/gzip",
+        "application/x-gzip",
+        "application/x-tar",
+        "application/x-compressed-tar",
+    },
+    "zip": {"application/zip"},
 }
 
 DOWNLOAD_CONTENT_TYPE: dict[ArtifactType, str] = {
@@ -168,6 +184,12 @@ def create(cls, user_id: str, source: APIKeySource, permissions: APIKeyPermissio
     "mjcf": "application/octet-stream",
     # Binary
     "stl": "application/octet-stream",
+    "obj": "application/octet-stream",
+    "dae": "application/octet-stream",
+    "ply": "application/octet-stream",
+    # Compressed
+    "tgz": "application/gzip",
+    "zip": "application/zip",
 }
 
 SizeMapping: dict[ArtifactSize, tuple[int, int]] = {
@@ -176,32 +198,90 @@ def create(cls, user_id: str, source: APIKeySource, permissions: APIKeyPermissio
 }
 
 
-def get_artifact_type(content_type: str, filename: str) -> ArtifactType:
+def get_artifact_type(content_type: str | None, filename: str | None) -> ArtifactType:
+    """Determines the artifact type from the content type or filename.
+
+    Args:
+        content_type: The content type of the file.
+        filename: The name of the file.
+
+    Returns:
+        The artifact type.
+
+    Raises:
+        ValueError: If the artifact type cannot be determined.
+    """
     # Attempts to determine from file extension.
-    extension = filename.split(".")[-1].lower()
-    if extension in ("png", "jpeg", "jpg", "gif", "webp"):
-        return "image"
-    if extension in ("urdf", "xml"):
-        return "urdf"
-    if extension in ("mjcf",):
-        return "mjcf"
-    if extension in ("stl",):
-        return "stl"
+    if filename is not None:
+        extension = filename.split(".")[-1].lower()
+        if extension in ("png", "jpeg", "jpg", "gif", "webp"):
+            return "image"
+        if extension in ("urdf",):
+            return "urdf"
+        if extension in ("mjcf", "xml"):
+            return "mjcf"
+        if extension in ("stl",):
+            return "stl"
+        if extension in ("obj",):
+            return "obj"
+        if extension in ("dae",):
+            return "dae"
+        if extension in ("ply",):
+            return "ply"
+        if extension in ("tgz", "tar.gz"):
+            return "tgz"
+        if extension in ("zip",):
+            return "zip"
 
     # Attempts to determine from content type.
-    if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["image"]:
-        return "image"
-    if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["urdf"]:
-        return "urdf"
-    if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["mjcf"]:
-        return "mjcf"
-    if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["stl"]:
-        return "stl"
+    if content_type is not None:
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["image"]:
+            return "image"
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["urdf"]:
+            return "urdf"
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["mjcf"]:
+            return "mjcf"
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["stl"]:
+            return "stl"
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["obj"]:
+            return "obj"
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["dae"]:
+            return "dae"
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["ply"]:
+            return "ply"
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["tgz"]:
+            return "tgz"
+        if content_type in UPLOAD_CONTENT_TYPE_OPTIONS["zip"]:
+            return "zip"
 
     # Throws a value error if the type cannot be determined.
     raise ValueError(f"Unknown content type for file: {filename}")
 
 
+def get_compression_type(content_type: str | None, filename: str | None) -> CompressedArtifactType:
+    artifact_type = get_artifact_type(content_type, filename)
+    if artifact_type not in (allowed_types := get_args(CompressedArtifactType)):
+        raise ValueError(f"Artifact type {artifact_type} is not compressed; expected one of {allowed_types}")
+    return cast(CompressedArtifactType, artifact_type)
+
+
+def check_content_type(content_type: str | None, artifact_type: ArtifactType) -> None:
+    """Checks that the content type is valid for the artifact type.
+
+    Args:
+        content_type: The content type of the artifact.
+        artifact_type: The type of the artifact.
+
+    Raises:
+        ValueError: If the content type is not valid for the artifact type.
+    """
+    if content_type is None:
+        raise ValueError("Artifact content type was not provided")
+    if content_type not in UPLOAD_CONTENT_TYPE_OPTIONS[artifact_type]:
+        content_type_options_string = ", ".join(UPLOAD_CONTENT_TYPE_OPTIONS[artifact_type])
+        raise ValueError(f"Invalid content type for artifact; {content_type} not in [{content_type_options_string}]")
+
+
 def get_content_type(artifact_type: ArtifactType) -> str:
     return DOWNLOAD_CONTENT_TYPE[artifact_type]
 
@@ -222,6 +302,7 @@ class Artifact(StoreBaseModel):
     sizes: list[ArtifactSize] | None = None
     description: str | None = None
     timestamp: int
+    children: list[str] | None = None
 
     @classmethod
     def create(
@@ -232,6 +313,7 @@ def create(
         artifact_type: ArtifactType,
         sizes: list[ArtifactSize] | None = None,
         description: str | None = None,
+        children: list[str] | None = None,
     ) -> Self:
         return cls(
             id=new_uuid(),
@@ -313,11 +395,7 @@ def get_artifact_name(
         case "image":
             height, width = SizeMapping[size]
             return f"{listing_id}/{size}_{height}x{width}_{name}"
-        case "urdf":
-            return f"{listing_id}/{name}"
-        case "mjcf":
-            return f"{listing_id}/{name}"
-        case "stl":
+        case "urdf" | "mjcf" | "stl" | "obj" | "ply" | "dae" | "zip" | "tgz":
             return f"{listing_id}/{name}"
         case _:
             raise ValueError(f"Unknown artifact type: {artifact_type}")
@@ -339,3 +417,37 @@ def get_artifact_url(
         size=size,
     )
     return f"{settings.site.artifact_base_url}/{artifact_name}"
+
+
+def get_artifact_urls(
+    artifact: Artifact | None = None,
+    artifact_type: ArtifactType | None = None,
+    listing_id: str | None = None,
+    name: str | None = None,
+) -> dict[ArtifactSize, str]:
+    return {
+        size: get_artifact_url(
+            artifact=artifact,
+            artifact_type=artifact_type,
+            listing_id=listing_id,
+            name=name,
+            size=size,
+        )
+        for size in SizeMapping.keys()
+    }
+
+
+async def can_write_artifact(user: User, artifact: Artifact) -> bool:
+    if user.permissions is not None and "is_admin" in user.permissions:
+        return True
+    if user.id == artifact.user_id:
+        return True
+    return False
+
+
+async def can_write_listing(user: User, listing: Listing) -> bool:
+    if user.permissions is not None and "is_admin" in user.permissions:
+        return True
+    if user.id == listing.user_id:
+        return True
+    return False
diff --git a/store/app/routers/artifacts.py b/store/app/routers/artifacts.py
index 376d80d1..a9d9ffd8 100644
--- a/store/app/routers/artifacts.py
+++ b/store/app/routers/artifacts.py
@@ -4,19 +4,22 @@
 import logging
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, Form, HTTPException, UploadFile, status
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, status
 from fastapi.responses import RedirectResponse
 from pydantic.main import BaseModel
 
 from store.app.db import Crud
 from store.app.model import (
-    UPLOAD_CONTENT_TYPE_OPTIONS,
     Artifact,
     ArtifactSize,
     ArtifactType,
     User,
+    can_write_artifact,
+    can_write_listing,
+    check_content_type,
     get_artifact_type,
     get_artifact_url,
+    get_artifact_urls,
 )
 from store.app.routers.users import get_session_user_with_write_permission
 from store.settings import settings
@@ -44,6 +47,19 @@ async def artifact_url(
     )
 
 
+class ArtifactUrls(BaseModel):
+    small: str | None = None
+    large: str
+
+
+def get_artifact_url_response(artifact: Artifact) -> ArtifactUrls:
+    artifact_urls = get_artifact_urls(artifact=artifact)
+    return ArtifactUrls(
+        small=artifact_urls.get("small"),
+        large=artifact_urls["large"],
+    )
+
+
 class ListArtifactsItem(BaseModel):
     artifact_id: str
     listing_id: str
@@ -51,7 +67,7 @@ class ListArtifactsItem(BaseModel):
     artifact_type: ArtifactType
     description: str | None
     timestamp: int
-    url: str
+    urls: ArtifactUrls
     is_new: bool | None = None
 
 
@@ -70,7 +86,7 @@ async def list_artifacts(listing_id: str, crud: Annotated[Crud, Depends(Crud.get
                 artifact_type=artifact.artifact_type,
                 description=artifact.description,
                 timestamp=artifact.timestamp,
-                url=get_artifact_url(artifact=artifact),
+                urls=get_artifact_url_response(artifact=artifact),
             )
             for artifact in await crud.get_listing_artifacts(listing_id)
         ],
@@ -98,42 +114,31 @@ def validate_file(file: UploadFile) -> tuple[str, ArtifactType]:
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"Artifact size is too large; {file.size} is greater than {settings.artifact.max_bytes} bytes",
         )
-    if (content_type := file.content_type) is None:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Artifact content type was not provided",
-        )
 
     # Parses the artifact type from the content type and filename.
-    artifact_type = get_artifact_type(content_type, file.filename)
-    if content_type not in UPLOAD_CONTENT_TYPE_OPTIONS[artifact_type]:
-        content_type_options_string = ", ".join(UPLOAD_CONTENT_TYPE_OPTIONS[artifact_type])
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Invalid content type {content_type}; expected one of {content_type_options_string}",
-        )
+    artifact_type = get_artifact_type(file.content_type, file.filename)
+    check_content_type(file.content_type, artifact_type)
 
     return file.filename, artifact_type
 
 
-class UploadArtifactRequest(BaseModel):
-    listing_id: str
-    description: str | None = None
-
-
 class UploadArtifactResponse(BaseModel):
     artifacts: list[ListArtifactsItem]
 
 
-@artifacts_router.post("/upload", response_model=UploadArtifactResponse)
+@artifacts_router.post("/upload/{listing_id}", response_model=UploadArtifactResponse)
 async def upload(
+    listing_id: str,
     user: Annotated[User, Depends(get_session_user_with_write_permission)],
     crud: Annotated[Crud, Depends(Crud.get)],
     files: list[UploadFile],
-    metadata: Annotated[str, Form()],
 ) -> UploadArtifactResponse:
-    # Converts the metadata JSON string to a Pydantic model.
-    data = UploadArtifactRequest.model_validate_json(metadata)
+    # Checks that the user is not uploading too many files at once.
+    if len(files) > settings.artifact.max_concurrent_file_uploads:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Too many files were uploaded concurrently",
+        )
     filenames = [validate_file(file) for file in files]
 
     # Makes sure that filenames are unique.
@@ -144,33 +149,30 @@ async def upload(
         )
 
     # Checks that the listing is valid.
-    listing = await crud.get_listing(data.listing_id)
+    listing = await crud.get_listing(listing_id)
     if listing is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail="Could not find listing associated with the given id",
         )
+    if not await can_write_listing(user, listing):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="User does not have permission to upload artifacts to this listing",
+        )
 
     # Uploads the artifacts in chunks and adds them to the listing.
-    artifacts: list[tuple[Artifact, bool]] = []
-    for chunk_start in range(0, len(files), settings.artifact.upload_chunk_size):
-        files_chunk = files[chunk_start : chunk_start + settings.artifact.upload_chunk_size]
-        filenames_chunk = filenames[chunk_start : chunk_start + settings.artifact.upload_chunk_size]
-        artifacts.extend(
-            await asyncio.gather(
-                *(
-                    crud.upload_artifact(
-                        file=file.file,
-                        name=filename,
-                        listing=listing,
-                        user_id=user.id,
-                        artifact_type=artifact_type,
-                        description=data.description,
-                    )
-                    for file, (filename, artifact_type) in zip(files_chunk, filenames_chunk)
-                )
+    artifacts = await asyncio.gather(
+        *(
+            crud.upload_artifact(
+                file=file,
+                name=filename,
+                listing=listing,
+                artifact_type=artifact_type,
             )
+            for file, (filename, artifact_type) in zip(files, filenames)
         )
+    )
 
     return UploadArtifactResponse(
         artifacts=[
@@ -181,7 +183,7 @@ async def upload(
                 artifact_type=artifact.artifact_type,
                 description=artifact.description,
                 timestamp=artifact.timestamp,
-                url=get_artifact_url(artifact=artifact),
+                urls=get_artifact_url_response(artifact=artifact),
                 is_new=is_new,
             )
             for artifact, is_new in artifacts
@@ -204,8 +206,11 @@ async def edit_artifact(
     artifact_info = await crud.get_raw_artifact(id)
     if artifact_info is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Artifact not found")
-    if artifact_info.user_id != user.id:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You do not own this artifact")
+    if not await can_write_artifact(user, artifact_info):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="You do not have permission to edit this artifact",
+        )
     await crud.edit_artifact(artifact_id=id, name=artifact.name, description=artifact.description)
     return True
 
@@ -222,8 +227,10 @@ async def delete_artifact(
             status_code=status.HTTP_404_NOT_FOUND,
             detail="Could not find artifact associated with the given id",
         )
-
-    # Deletes the artifact from the listing.
-    await crud.remove_artifact(artifact, user.id)
-
+    if not await can_write_artifact(user, artifact):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="User does not have permission to delete this artifact",
+        )
+    await crud.remove_artifact(artifact)
     return True
diff --git a/store/app/routers/listings.py b/store/app/routers/listings.py
index 62c69817..1d01658d 100644
--- a/store/app/routers/listings.py
+++ b/store/app/routers/listings.py
@@ -8,7 +8,7 @@
 from pydantic import BaseModel
 
 from store.app.db import Crud
-from store.app.model import Listing, User, get_artifact_url
+from store.app.model import Listing, User, can_write_listing, get_artifact_url
 from store.app.routers.users import (
     get_session_user_with_read_permission,
     get_session_user_with_write_permission,
@@ -115,37 +115,8 @@ class NewListingResponse(BaseModel):
 async def add_listing(
     user: Annotated[User, Depends(get_session_user_with_write_permission)],
     crud: Annotated[Crud, Depends(Crud.get)],
-    # metadata: Annotated[str, Form()],
-    # files: list[UploadFile] = Form(...),
     data: NewListingRequest,
 ) -> NewListingResponse:
-    # # Checks that the content type is valid.
-    # for file in files:
-    #     if file.filename is None:
-    #         raise HTTPException(
-    #             status_code=status.HTTP_400_BAD_REQUEST,
-    #             detail="Image filename was not provided",
-    #         )
-    #     if file.size is None or file.size < settings.image.min_bytes or file.size > settings.image.max_bytes:
-    #         raise HTTPException(
-    #             status_code=status.HTTP_400_BAD_REQUEST,
-    #             detail="Invalid image size",
-    #         )
-    #     if (content_type := file.content_type) is None:
-    #         raise HTTPException(
-    #             status_code=status.HTTP_400_BAD_REQUEST,
-    #             detail="Artifact content type was not provided",
-    #         )
-    #     if content_type not in UPLOAD_CONTENT_TYPE_OPTIONS["image"]:
-    #         content_type_options_string = ", ".join(UPLOAD_CONTENT_TYPE_OPTIONS["image"])
-    #         raise HTTPException(
-    #             status_code=status.HTTP_400_BAD_REQUEST,
-    #             detail=f"Invalid content type {content_type}; expected one of {content_type_options_string}",
-    #         )
-
-    # Converts the metadata JSON string to a Pydantic model.
-    # data = NewListingRequest.model_validate_json(metadata)
-
     # Creates a new listing.
     listing = Listing.create(
         name=data.name,
@@ -154,20 +125,6 @@ async def add_listing(
         child_ids=data.child_ids,
     )
     await crud.add_listing(listing)
-
-    # Uploads all the images.
-    # await asyncio.gather(
-    #     crud.upload_artifact(
-    #         file=file.file,
-    #         name=cast(str, file.filename),  # Validated above.
-    #         listing=listing,
-    #         user_id=user.id,
-    #         artifact_type="image",
-    #         description=data.description,
-    #     )
-    #     for file in files
-    # )
-
     return NewListingResponse(listing_id=listing.id)
 
 
@@ -180,8 +137,11 @@ async def delete_listing(
     listing = await crud.get_listing(listing_id)
     if listing is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Listing not found")
-    if listing.user_id != user.id:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You do not own this listing")
+    if not await can_write_listing(user, listing):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="You do not have permission to delete this listing.",
+        )
     await crud.delete_listing(listing)
     return True
 
@@ -203,8 +163,11 @@ async def edit_listing(
     listing_info = await crud.get_listing(id)
     if listing_info is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Listing not found.")
-    if listing_info.user_id != user.id:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You do not own this listing.")
+    if not await can_write_listing(user, listing_info):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="You do not have permission to edit this listing.",
+        )
     if listing.name is not None and len(listing.name) < 4:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -231,7 +194,7 @@ class GetListingResponse(BaseModel):
     description: str | None
     child_ids: list[str]
     tags: list[str]
-    owner_is_user: bool
+    can_edit: bool
 
 
 @listings_router.get("/{id}", response_model=GetListingResponse)
@@ -252,5 +215,5 @@ async def get_listing(
         description=listing.description,
         child_ids=listing.child_ids,
         tags=listing_tags,
-        owner_is_user=user is not None and user.id == listing.user_id,
+        can_edit=user is not None and await can_write_listing(user, listing),
     )
diff --git a/store/app/routers/urdf.py b/store/app/routers/urdf.py
new file mode 100644
index 00000000..bc6746d7
--- /dev/null
+++ b/store/app/routers/urdf.py
@@ -0,0 +1,128 @@
+"""Defines the router endpoints for handling URDFs."""
+
+import asyncio
+import logging
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, status
+from pydantic.main import BaseModel
+
+from store.app.crud.urdf import URDF_PACKAGE_NAME
+from store.app.db import Crud
+from store.app.model import (
+    User,
+    can_write_listing,
+    get_artifact_url,
+    get_compression_type,
+)
+from store.app.routers.users import get_session_user_with_write_permission
+
+urdf_router = APIRouter()
+
+logger = logging.getLogger(__name__)
+
+
+def get_urdf_url(listing_id: str) -> str:
+    return get_artifact_url(
+        artifact_type="urdf",
+        listing_id=listing_id,
+        name=URDF_PACKAGE_NAME,
+    )
+
+
+class UrdfInfo(BaseModel):
+    artifact_id: str
+    url: str
+
+
+class UrdfResponse(BaseModel):
+    urdf: UrdfInfo | None
+    listing_id: str
+
+
+@urdf_router.get("/info/{listing_id}", response_model=UrdfResponse)
+async def get_urdf(
+    listing_id: str,
+    crud: Annotated[Crud, Depends(Crud.get)],
+) -> UrdfResponse:
+    urdf = await crud.get_urdf(listing_id)
+    if urdf is None:
+        return UrdfResponse(urdf=None, listing_id=listing_id)
+    return UrdfResponse(
+        urdf=UrdfInfo(artifact_id=urdf.id, url=get_urdf_url(listing_id)),
+        listing_id=listing_id,
+    )
+
+
+class SetUrdfResponse(BaseModel):
+    urdf: UrdfInfo
+
+
+@urdf_router.post("/upload/{listing_id}")
+async def set_urdf(
+    listing_id: str,
+    user: Annotated[User, Depends(get_session_user_with_write_permission)],
+    crud: Annotated[Crud, Depends(Crud.get)],
+    file: UploadFile,
+) -> UrdfResponse:
+    # Gets the compression type from the file content type and filename.
+    compression_type = get_compression_type(file.content_type, file.filename)
+    if compression_type not in ("tgz", "zip"):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="The file must be a .tgz or .zip file",
+        )
+
+    # Checks that the listing is valid.
+    listing = await crud.get_listing(listing_id)
+    if listing is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Could not find listing associated with the given id",
+        )
+    if not await can_write_listing(user, listing):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="User does not have permission to upload artifacts to this listing",
+        )
+
+    # Uploads the URDF for the listing.
+    urdf = await crud.set_urdf(
+        file=file,
+        listing=listing,
+        compression_type=compression_type,
+    )
+
+    return UrdfResponse(
+        urdf=UrdfInfo(artifact_id=urdf.id, url=get_urdf_url(listing.id)),
+        listing_id=listing.id,
+    )
+
+
+@urdf_router.delete("/delete/{listing_id}")
+async def delete_urdf(
+    listing_id: str,
+    user: Annotated[User, Depends(get_session_user_with_write_permission)],
+    crud: Annotated[Crud, Depends(Crud.get)],
+) -> UrdfResponse:
+    urdf, listing = await asyncio.gather(
+        crud.get_urdf(listing_id),
+        crud.get_listing(listing_id),
+    )
+    if urdf is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Could not find URDF associated with the given listing id",
+        )
+    if listing is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Could not find listing associated with the given id",
+        )
+    if not await can_write_listing(user, listing):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="User does not have permission to delete the URDF for this listing",
+        )
+    await crud.remove_artifact(urdf)
+    return UrdfResponse(urdf=None, listing_id=listing_id)
diff --git a/store/requirements.txt b/store/requirements.txt
index 63303996..628dc0ce 100644
--- a/store/requirements.txt
+++ b/store/requirements.txt
@@ -27,6 +27,7 @@ uvicorn[standard]
 
 # Processing dependencies.
 numpy-stl
+trimesh
 
 # Types
 types-aioboto3[dynamodb, s3]
diff --git a/store/settings/environment.py b/store/settings/environment.py
index c2052137..048ef04b 100644
--- a/store/settings/environment.py
+++ b/store/settings/environment.py
@@ -44,7 +44,7 @@ class ArtifactSettings:
     min_bytes: int = field(default=16)
     max_bytes: int = field(default=1536 * 1536 * 25)
     quality: int = field(default=80)
-    upload_chunk_size: int = field(default=10)
+    max_concurrent_file_uploads: int = field(default=3)
 
 
 @dataclass
diff --git a/tests/test_images.py b/tests/test_images.py
index 2a9c7721..cfaf49be 100644
--- a/tests/test_images.py
+++ b/tests/test_images.py
@@ -36,10 +36,9 @@ async def test_user_auth_functions(app_client: AsyncClient, tmpdir: Path) -> Non
     image = Image.new("RGB", (100, 100))
     image_path = Path(tmpdir) / "test.png"
     image.save(image_path)
-    data_json = json.dumps({"artifact_type": "image", "listing_id": listing_id})
     response = await app_client.post(
-        "/artifacts/upload",
-        files={"files": ("test.png", open(image_path, "rb"), "image/png"), "metadata": (None, data_json)},
+        f"/artifacts/upload/{listing_id}",
+        files={"files": ("test.png", open(image_path, "rb"), "image/png")},
         headers=auth_headers,
     )
     assert response.status_code == status.HTTP_200_OK, response.json()
diff --git a/tests/test_listings.py b/tests/test_listings.py
index d0cb6d08..454c9991 100644
--- a/tests/test_listings.py
+++ b/tests/test_listings.py
@@ -1,6 +1,8 @@
 """Runs tests on the robot APIs."""
 
-import json
+import tarfile
+import tempfile
+import zipfile
 from pathlib import Path
 
 from fastapi import status
@@ -36,11 +38,10 @@ async def test_listings(app_client: AsyncClient, tmpdir: Path) -> None:
     image = Image.new("RGB", (100, 100))
     image_path = Path(tmpdir) / "test.png"
     image.save(image_path)
-    data_json = json.dumps({"listing_id": listing_id})
     response = await app_client.post(
-        "/artifacts/upload",
+        f"/artifacts/upload/{listing_id}",
         headers=auth_headers,
-        files={"files": ("test.png", open(image_path, "rb"), "image/png"), "metadata": (None, data_json)},
+        files={"files": ("test.png", open(image_path, "rb"), "image/png")},
     )
     assert response.status_code == status.HTTP_200_OK, response.json()
     data = response.json()
@@ -48,11 +49,10 @@ async def test_listings(app_client: AsyncClient, tmpdir: Path) -> None:
 
     # Uploads a URDF.
     urdf_path = Path(__file__).parent / "assets" / "sample.urdf"
-    data_json = json.dumps({"listing_id": listing_id})
     response = await app_client.post(
-        "/artifacts/upload",
+        f"/artifacts/upload/{listing_id}",
         headers=auth_headers,
-        files={"files": ("box.urdf", open(urdf_path, "rb"), "application/xml"), "metadata": (None, data_json)},
+        files={"files": ("box.urdf", open(urdf_path, "rb"), "application/xml")},
     )
     assert response.status_code == status.HTTP_200_OK, response.json()
     data = response.json()
@@ -66,31 +66,54 @@ async def test_listings(app_client: AsyncClient, tmpdir: Path) -> None:
 
     # Uploads an STL.
     stl_path = Path(__file__).parent / "assets" / "teapot.stl"
-    data_json = json.dumps({"listing_id": listing_id})
     response = await app_client.post(
-        "/artifacts/upload",
+        f"/artifacts/upload/{listing_id}",
         headers=auth_headers,
         files={
             "files": ("teapot.stl", open(stl_path, "rb"), "application/octet-stream"),
-            "metadata": (None, data_json),
         },
     )
     assert response.status_code == status.HTTP_200_OK, response.json()
     data = response.json()
     assert data["artifacts"][0]["artifact_id"] is not None
 
+    # Uploads a combined URDF + STL as a tarball.
+    with tempfile.NamedTemporaryFile(suffix=".tgz") as f:
+        with tarfile.open(f.name, "w:gz") as tar:
+            tar.add(urdf_path, arcname="box.urdf")
+            tar.add(stl_path, arcname="teapot.stl")
+        f.seek(0)
+        response = await app_client.post(
+            f"/urdf/upload/{listing_id}",
+            headers=auth_headers,
+            files={"file": (f.name, open(f.name, "rb"), "application/gzip")},
+        )
+        assert response.status_code == status.HTTP_200_OK, response.json()
+        data = response.json()
+        assert data["urdf"]["artifact_id"] is not None
+
+    # Uploads a combined URDF + STL as a zipfile.
+    with tempfile.NamedTemporaryFile(suffix=".zip") as f:
+        with zipfile.ZipFile(f.name, "w") as zipf:
+            zipf.write(urdf_path, arcname="box.urdf")
+            zipf.write(stl_path, arcname="teapot.stl")
+        f.seek(0)
+        response = await app_client.post(
+            f"/urdf/upload/{listing_id}",
+            headers=auth_headers,
+            files={"file": (f.name, open(f.name, "rb"), "application/zip")},
+        )
+        assert response.status_code == status.HTTP_200_OK, response.json()
+        data = response.json()
+        assert data["urdf"]["artifact_id"] is not None
+
     # Ensures that trying to upload the same STL again fails.
     response = await app_client.post(
-        "/artifacts/upload",
+        f"/artifacts/upload/{listing_id}",
         headers=auth_headers,
-        files={
-            "files": ("teapot.stl", open(stl_path, "rb"), "application/octet-stream"),
-            "metadata": (None, data_json),
-        },
+        files={"files": ("teapot.stl", open(stl_path, "rb"), "application/octet-stream")},
     )
     assert response.status_code == status.HTTP_200_OK, response.json()
-    data = response.json()
-    assert data["artifacts"][0]["is_new"] is False
 
     # Searches for listings.
     response = await app_client.get(