feat(artifact-apps): automatic marketplace catalog, restore, and shared-view guards

api/server/controllers/UserController.js

@@ -548,6 +548,7 @@ const deleteUserController = async (req, res) => {
     await db.deleteAllUserMemories(user.id);
     await db.deleteUserPrompts(user.id);
     await db.deleteUserSkills(user.id);
+    await db.deleteUserArtifactApps(user.id);
     await deleteUserMcpServers(user.id);
     await db.deleteActions({ user: user.id });
     await db.deleteTokens({ userId: user.id });

api/server/controllers/UserController.spec.js

@@ -60,6 +60,7 @@ jest.mock('~/models', () => {
     cancelAgentTriggerUserDeletion: jest.fn().mockResolvedValue(true),
     deleteUserPrompts: jest.fn().mockResolvedValue(undefined),
     deleteUserSkills: jest.fn().mockResolvedValue(undefined),
+    deleteUserArtifactApps: jest.fn().mockResolvedValue(undefined),
     deleteUserCodeEnvironments: jest.fn().mockResolvedValue(undefined),
     deleteMessages: jest.fn().mockResolvedValue(undefined),
     deleteBalances: jest.fn().mockResolvedValue(undefined),

api/server/controllers/__tests__/deleteUser.spec.js

@@ -19,6 +19,7 @@ const mockDeleteToolCalls = jest.fn();
 const mockDeleteUserAgents = jest.fn();
 const mockDeleteUserPrompts = jest.fn();
 const mockDeleteUserSkills = jest.fn();
+const mockDeleteUserArtifactApps = jest.fn();
 const mockDeleteUserCodeEnvironments = jest.fn();
 const mockInvalidateCodeEnvironmentConfigCache = jest.fn();
 const mockGetCleanupBlockingJobIdsForUser = jest.fn();
@@ -106,6 +107,7 @@ jest.mock('~/models', () => ({
   deleteUserAgents: (...args) => mockDeleteUserAgents(...args),
   deleteUserPrompts: (...args) => mockDeleteUserPrompts(...args),
   deleteUserSkills: (...args) => mockDeleteUserSkills(...args),
+  deleteUserArtifactApps: (...args) => mockDeleteUserArtifactApps(...args),
   deleteUserCodeEnvironments: (...args) => mockDeleteUserCodeEnvironments(...args),
   deleteTransactions: jest.fn(),
   deleteBalances: jest.fn(),

api/server/controllers/__tests__/deleteUserResourceCoverage.spec.js

@@ -18,6 +18,7 @@ const HANDLED_RESOURCE_TYPES = {
   [ResourceType.MCPSERVER]: 'deleteUserMcpServers',
   [ResourceType.SKILL]: 'deleteUserSkills',
   [ResourceType.SHARED_LINK]: 'deleteAllSharedLinksWithCleanup',
+  [ResourceType.ARTIFACT_APP]: 'deleteUserArtifactApps',
 };
 
 /**

api/server/controllers/__tests__/maybeUninstallOAuthMCP.spec.js

@@ -147,6 +147,8 @@ jest.mock('~/models', () => ({
   deleteToolCalls: jest.fn(),
   deleteUserAgents: jest.fn(),
   deleteUserPrompts: jest.fn(),
+  deleteUserSkills: jest.fn(),
+  deleteUserArtifactApps: jest.fn(),
   deleteTransactions: jest.fn(),
   deleteBalances: jest.fn(),
   deleteAllAgentApiKeys: jest.fn(),

api/server/index.js

@@ -426,6 +426,7 @@ const startServer = async () => {
   app.use('/api/projects', routes.projects);
   app.use('/api/prompts', routes.prompts);
   app.use('/api/skills', routes.skills);
+  app.use('/api/artifact-apps', routes.artifactApps);
   app.use('/api/categories', routes.categories);
   app.use('/api/endpoints', routes.endpoints);
   app.use('/api/balance', routes.balance);

api/server/middleware/accessResources/canAccessArtifactAppResource.js

@@ -0,0 +1,34 @@
+const { ResourceType } = require('librechat-data-provider');
+const { canAccessResource } = require('./canAccessResource');
+const { resolveArtifactAppId } = require('~/models');
+
+/**
+ * Artifact-app-specific middleware factory that checks access permissions.
+ * Wraps the generic `canAccessResource` with the ARTIFACT_APP resource type and
+ * `resolveArtifactAppId` (custom `app_*` id → ObjectId) as the ID resolver.
+ *
+ * @param {Object} options
+ * @param {number} options.requiredPermission - Permission bit required (1=view, 2=edit, 4=delete, 8=share)
+ * @param {string} [options.resourceIdParam='id'] - Route parameter holding the artifact app id
+ * @returns {Function} Express middleware
+ */
+const canAccessArtifactAppResource = (options) => {
+  const { requiredPermission, resourceIdParam = 'id' } = options || {};
+
+  if (!requiredPermission || typeof requiredPermission !== 'number') {
+    throw new Error(
+      'canAccessArtifactAppResource: requiredPermission is required and must be a number',
+    );
+  }
+
+  return canAccessResource({
+    resourceType: ResourceType.ARTIFACT_APP,
+    requiredPermission,
+    resourceIdParam,
+    idResolver: (artifactAppId) => resolveArtifactAppId({ artifactAppId }),
+  });
+};
+
+module.exports = {
+  canAccessArtifactAppResource,
+};

api/server/middleware/accessResources/canAccessArtifactAppResource.spec.js

@@ -0,0 +1,203 @@
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const { ResourceType, PrincipalType, PrincipalModel } = require('librechat-data-provider');
+const { canAccessArtifactAppResource } = require('./canAccessArtifactAppResource');
+const { User, Role, AclEntry } = require('~/db/models');
+const { createArtifactAppWithVersion } = require('~/models');
+
+const VIEW = 1;
+const EDIT = 2;
+const DELETE = 4;
+
+/** Owner ACL bits (view+edit+delete+share), matching what publish grants. */
+const OWNER_BITS = 15;
+
+describe('canAccessArtifactAppResource middleware', () => {
+  let mongoServer;
+  let req, res, next;
+  let testUser;
+
+  const publishApp = async (createdBy) =>
+    createArtifactAppWithVersion({
+      title: 'Test App',
+      visibility: 'private',
+      createdBy: String(createdBy),
+      version: {
+        artifactType: 'react',
+        sourceSnapshot: 'export default () => <div>hi</div>;',
+        createdBy: String(createdBy),
+      },
+    });
+
+  const grant = async ({ principalId, resourceId, permBits, grantedBy }) =>
+    AclEntry.create({
+      principalType: PrincipalType.USER,
+      principalId,
+      principalModel: PrincipalModel.USER,
+      resourceType: ResourceType.ARTIFACT_APP,
+      resourceId,
+      permBits,
+      grantedBy: grantedBy ?? principalId,
+    });
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    await mongoose.connect(mongoServer.getUri());
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  beforeEach(async () => {
+    await mongoose.connection.dropDatabase();
+    await Role.create({ name: 'test-role', permissions: {} });
+    testUser = await User.create({
+      email: 'test@example.com',
+      name: 'Test User',
+      username: 'testuser',
+      role: 'test-role',
+    });
+
+    req = { user: { id: testUser._id, role: testUser.role }, params: {} };
+    res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+    next = jest.fn();
+    jest.clearAllMocks();
+  });
+
+  describe('middleware factory', () => {
+    test('throws when requiredPermission is missing', () => {
+      expect(() => canAccessArtifactAppResource({})).toThrow(
+        'canAccessArtifactAppResource: requiredPermission is required and must be a number',
+      );
+    });
+
+    test('throws when requiredPermission is not a number', () => {
+      expect(() => canAccessArtifactAppResource({ requiredPermission: '1' })).toThrow(
+        'canAccessArtifactAppResource: requiredPermission is required and must be a number',
+      );
+    });
+
+    test('throws when called with no options at all', () => {
+      expect(() => canAccessArtifactAppResource()).toThrow(
+        'canAccessArtifactAppResource: requiredPermission is required and must be a number',
+      );
+    });
+
+    test('returns an express middleware with the default resourceIdParam', () => {
+      const middleware = canAccessArtifactAppResource({ requiredPermission: VIEW });
+      expect(typeof middleware).toBe('function');
+      expect(middleware.length).toBe(3);
+    });
+  });
+
+  describe('permission checking against real ACL entries', () => {
+    test('allows the owner to view their own app', async () => {
+      const { app } = await publishApp(testUser._id);
+      await grant({ principalId: testUser._id, resourceId: app.id, permBits: OWNER_BITS });
+      req.params.id = app.artifactAppId;
+
+      await canAccessArtifactAppResource({ requiredPermission: VIEW })(req, res, next);
+
+      expect(next).toHaveBeenCalled();
+      expect(res.status).not.toHaveBeenCalled();
+    });
+
+    test('denies a user with no ACL entry for the app', async () => {
+      const otherUser = await User.create({
+        email: 'other@example.com',
+        name: 'Other User',
+        username: 'otheruser',
+        role: 'test-role',
+      });
+      const { app } = await publishApp(otherUser._id);
+      await grant({ principalId: otherUser._id, resourceId: app.id, permBits: OWNER_BITS });
+      req.params.id = app.artifactAppId;
+
+      await canAccessArtifactAppResource({ requiredPermission: VIEW })(req, res, next);
+
+      expect(next).not.toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(403);
+      expect(res.json).toHaveBeenCalledWith({
+        error: 'Forbidden',
+        message: `Insufficient permissions to access this ${ResourceType.ARTIFACT_APP}`,
+      });
+    });
+
+    /* The route table gates PATCH on EDIT and DELETE on DELETE, so a
+     * view-only grant must not satisfy either. */
+    test.each([
+      ['edit', EDIT],
+      ['delete', DELETE],
+    ])('denies %s when the grant is view-only', async (_label, requiredPermission) => {
+      const { app } = await publishApp(testUser._id);
+      await grant({ principalId: testUser._id, resourceId: app.id, permBits: VIEW });
+      req.params.id = app.artifactAppId;
+
+      await canAccessArtifactAppResource({ requiredPermission })(req, res, next);
+
+      expect(next).not.toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(403);
+    });
+
+    test('allows edit when the grant carries edit bits', async () => {
+      const { app } = await publishApp(testUser._id);
+      await grant({ principalId: testUser._id, resourceId: app.id, permBits: VIEW | EDIT });
+      req.params.id = app.artifactAppId;
+
+      await canAccessArtifactAppResource({ requiredPermission: EDIT })(req, res, next);
+
+      expect(next).toHaveBeenCalled();
+      expect(res.status).not.toHaveBeenCalled();
+    });
+
+    test('returns 404 for an unknown artifact app id', async () => {
+      req.params.id = 'app_does_not_exist';
+
+      await canAccessArtifactAppResource({ requiredPermission: VIEW })(req, res, next);
+
+      expect(next).not.toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(404);
+      expect(res.json).toHaveBeenCalledWith({
+        error: 'Not Found',
+        message: `${ResourceType.ARTIFACT_APP} not found`,
+      });
+    });
+
+    /* A grant on the same ObjectId under a different resourceType must not
+     * leak across: ACL rows are keyed by (resourceType, resourceId). */
+    test('ignores a grant recorded under a different resourceType', async () => {
+      const { app } = await publishApp(testUser._id);
+      await AclEntry.create({
+        principalType: PrincipalType.USER,
+        principalId: testUser._id,
+        principalModel: PrincipalModel.USER,
+        resourceType: ResourceType.AGENT,
+        resourceId: app.id,
+        permBits: OWNER_BITS,
+        grantedBy: testUser._id,
+      });
+      req.params.id = app.artifactAppId;
+
+      await canAccessArtifactAppResource({ requiredPermission: VIEW })(req, res, next);
+
+      expect(next).not.toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(403);
+    });
+
+    test('reads the app id from a custom resourceIdParam', async () => {
+      const { app } = await publishApp(testUser._id);
+      await grant({ principalId: testUser._id, resourceId: app.id, permBits: OWNER_BITS });
+      req.params.appId = app.artifactAppId;
+
+      await canAccessArtifactAppResource({
+        requiredPermission: VIEW,
+        resourceIdParam: 'appId',
+      })(req, res, next);
+
+      expect(next).toHaveBeenCalled();
+      expect(res.status).not.toHaveBeenCalled();
+    });
+  });
+});

api/server/middleware/accessResources/index.js

@@ -5,6 +5,7 @@ const { canAccessPromptViaGroup } = require('./canAccessPromptViaGroup');
 const { canAccessPromptGroupResource } = require('./canAccessPromptGroupResource');
 const { canAccessMCPServerResource } = require('./canAccessMCPServerResource');
 const { canAccessSkillResource } = require('./canAccessSkillResource');
+const { canAccessArtifactAppResource } = require('./canAccessArtifactAppResource');
 
 module.exports = {
   canAccessResource,
@@ -14,4 +15,5 @@ module.exports = {
   canAccessPromptGroupResource,
   canAccessMCPServerResource,
   canAccessSkillResource,
+  canAccessArtifactAppResource,
 };

api/server/routes/accessPermissions.js

@@ -6,7 +6,11 @@ const {
   ResourceType,
   PermissionBits,
 } = require('librechat-data-provider');
-const { createAgentAdminPermissionAccess, isAgentPermissionsAdmin } = require('@librechat/api');
+const {
+  createAgentAdminPermissionAccess,
+  createArtifactAppSharingPolicy,
+  isAgentPermissionsAdmin,
+} = require('@librechat/api');
 const {
   getUserEffectivePermissions,
   getAllEffectivePermissions,
@@ -25,6 +29,9 @@ const db = require('~/models');
 const { findMCPServerByObjectId, getSkillById } = db;
 
 const router = express.Router();
+const enforceArtifactAppSharingPolicy = createArtifactAppSharingPolicy({
+  getArtifactAppsByIds: db.getArtifactAppsByIds,
+});
 
 // Apply common middleware
 router.use(requireJwtAuth);
@@ -99,6 +106,12 @@ const checkResourcePermissionAccess = (requiredPermission) =>
           requiredPermission,
           resourceIdParam: 'resourceId',
         });
+      } else if (resourceType === ResourceType.ARTIFACT_APP) {
+        middleware = canAccessResource({
+          resourceType: ResourceType.ARTIFACT_APP,
+          requiredPermission,
+          resourceIdParam: 'resourceId',
+        });
       } else if (resourceType === ResourceType.SHARED_LINK) {
         middleware = canAccessResource({
           resourceType: ResourceType.SHARED_LINK,
@@ -197,6 +210,7 @@ router.put(
   checkResourcePermissionAccess(PermissionBits.SHARE),
   checkShareAccessUnlessAgentAdmin,
   checkSharePublicAccess,
+  enforceArtifactAppSharingPolicy,
   rejectSharedLinkOwnerPermissionChanges,
   updateResourcePermissions,
 );