@jk3labs/paperclip-plugin-file-browser 0.2.4 → 0.2.6

package/package.json

@@ -1,34 +1,48 @@
-{
-  "name": "@jk3labs/paperclip-plugin-file-browser",
-  "version": "0.2.4",
-  "description": "A Paperclip plugin for browsing files in the workspace",
-  "main": "index.js",
-  "scripts": {
-    "test": "jest",
-    "test:watch": "jest --watch"
-  },
-  "keywords": [
-    "paperclip",
-    "plugin",
-    "file-browser"
-  ],
-  "author": "JKL",
-  "license": "ISC",
-  "dependencies": {
-    "@types/archiver": "^7.0.0",
-    "archiver": "^8.0.0",
-    "express": "^4.18.2",
-    "fs-extra": "^11.1.1"
-  },
-  "devDependencies": {
-    "@types/express": "^5.0.6",
-    "@types/fs-extra": "^11.0.4",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^25.9.1",
-    "@types/supertest": "^7.2.0",
-    "jest": "^30.4.2",
-    "supertest": "^7.2.2",
-    "ts-jest": "^29.4.11",
-    "typescript": "^6.0.3"
-  }
-}
+{
+  "name": "@jk3labs/paperclip-plugin-file-browser",
+  "version": "0.2.6",
+  "type": "module",
+  "description": "A file browser plugin for Paperclip workspaces",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ./esbuild.config.mjs",
+    "build:rollup": "rollup -c",
+    "dev": "node ./esbuild.config.mjs --watch",
+    "dev:ui": "paperclip-plugin-dev-server --root . --ui-dir dist/ui --port 4177",
+    "test": "vitest run --config ./vitest.config.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "paperclipPlugin": {
+    "manifest": "./dist/manifest.js",
+    "worker": "./dist/worker.js",
+    "ui": "./dist/ui/"
+  },
+  "keywords": [
+    "paperclip",
+    "plugin",
+    "workspace"
+  ],
+  "author": "JK3Labs",
+  "license": "MIT",
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@paperclipai/plugin-sdk": "2026.525.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^24.6.0",
+    "@types/react": "^19.0.8",
+    "esbuild": "^0.27.3",
+    "rollup": "^4.38.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
+  }
+}

package/dist/__tests__/file-browser.spec.js

@@ -1,140 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const express_1 = __importDefault(require("express"));
-const supertest_1 = __importDefault(require("supertest"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-jest.mock('archiver', () => {
-    return jest.fn().mockImplementation(() => {
-        const { PassThrough } = require('stream');
-        const stream = new PassThrough();
-        setTimeout(() => { stream.end(); }, 50);
-        return {
-            pipe: (dest) => { stream.pipe(dest); return dest; },
-            directory: () => { },
-            finalize: jest.fn().mockResolvedValue(undefined),
-        };
-    });
-});
-const index_1 = __importDefault(require("../index"));
-const mockRootDir = path_1.default.join(__dirname, 'mock-root');
-function createApp() {
-    const app = (0, express_1.default)();
-    const routers = [];
-    const context = {
-        addRouter: (basePath, router) => {
-            routers.push({ basePath, router });
-        },
-        environment: {
-            rootDir: mockRootDir,
-        },
-    };
-    index_1.default.register(context);
-    for (const { basePath, router } of routers) {
-        app.use(basePath, router);
-    }
-    return app;
-}
-describe('File Browser Plugin', () => {
-    let app;
-    const mockFilePath = path_1.default.join(mockRootDir, 'test.txt');
-    const mockDirPath = path_1.default.join(mockRootDir, 'test-dir');
-    const mockNestedFilePath = path_1.default.join(mockDirPath, 'nested.txt');
-    beforeAll(async () => {
-        await fs_extra_1.default.ensureDir(mockRootDir);
-        await fs_extra_1.default.writeFile(mockFilePath, 'test content');
-        await fs_extra_1.default.ensureDir(mockDirPath);
-        await fs_extra_1.default.writeFile(mockNestedFilePath, 'nested content');
-        app = createApp();
-    });
-    afterAll(async () => {
-        await fs_extra_1.default.remove(mockRootDir);
-    });
-    describe('Plugin registration', () => {
-        it('should throw if rootDir is invalid', () => {
-            const badContext = {
-                addRouter: () => { },
-                environment: { rootDir: '/nonexistent/path/that/does/not/exist' },
-            };
-            expect(() => index_1.default.register(badContext)).toThrow('Invalid root directory');
-        });
-        it('should register a router on /files', () => {
-            const registeredPaths = [];
-            const ctx = {
-                addRouter: (basePath) => { registeredPaths.push(basePath); },
-                environment: { rootDir: mockRootDir },
-            };
-            index_1.default.register(ctx);
-            expect(registeredPaths).toContain('/files');
-        });
-    });
-    describe('GET /files/list', () => {
-        it('should list files and directories in root', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/list');
-            expect(response.status).toBe(200);
-            expect(response.body.files).toContain('test.txt');
-            expect(response.body.directories).toContain('test-dir');
-            expect(response.body.currentPath).toBe('');
-        });
-        it('should list files and directories in subdirectory', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/list?path=test-dir');
-            expect(response.status).toBe(200);
-            expect(response.body.files).toContain('nested.txt');
-            expect(response.body.directories).toEqual([]);
-        });
-        it('should return 404 for non-existent directory', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/list?path=non-existent');
-            expect(response.status).toBe(404);
-        });
-        it('should return 403 for path traversal attempt', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/list?path=../../../etc');
-            expect(response.status).toBe(403);
-        });
-    });
-    describe('GET /files/download', () => {
-        it('should download a file', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/download?path=test.txt');
-            expect(response.status).toBe(200);
-            expect(response.text).toBe('test content');
-        });
-        it('should return 400 when path is missing', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/download');
-            expect(response.status).toBe(400);
-            expect(response.body.error).toBe('Path parameter is required');
-        });
-        it('should return 404 for non-existent file', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/download?path=non-existent.txt');
-            expect(response.status).toBe(404);
-        });
-        it('should return 403 for path traversal attempt', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/download?path=../../../etc/passwd');
-            expect(response.status).toBe(403);
-        });
-    });
-    describe('GET /files/zip', () => {
-        it('should return a zip response for a valid directory', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/zip?path=test-dir');
-            expect(response.status).toBe(200);
-        });
-        it('should return 400 when path is missing', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/zip');
-            expect(response.status).toBe(400);
-            expect(response.body.error).toBe('Path parameter is required');
-        });
-        it('should return 404 for non-existent directory', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/zip?path=non-existent');
-            expect(response.status).toBe(404);
-        });
-        it('should return 404 when path points to a file', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/zip?path=test.txt');
-            expect(response.status).toBe(404);
-        });
-        it('should return 403 for path traversal attempt', async () => {
-            const response = await (0, supertest_1.default)(app).get('/files/zip?path=../../../etc');
-            expect(response.status).toBe(403);
-        });
-    });
-});

package/dist/index.js

@@ -1,110 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const express_1 = __importDefault(require("express"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const archiver_1 = __importDefault(require("archiver"));
-;
-const plugin = {
-    id: 'file-browser',
-    name: 'File Browser Plugin',
-    description: 'A plugin to browse, download, and zip files in the Paperclip workspace.',
-    register: (context) => {
-        const router = express_1.default.Router();
-        const rootDir = context.environment.rootDir;
-        // Validate rootDir exists
-        if (!rootDir || !(fs_extra_1.default.existsSync(rootDir))) {
-            throw new Error(`Invalid root directory: ${rootDir}`);
-        }
-        router.get('/list', async (req, res) => {
-            try {
-                const relativePath = req.query.path || '';
-                const targetPath = path_1.default.join(rootDir, relativePath);
-                // Security: Ensure targetPath is within rootDir
-                if (!targetPath.startsWith(rootDir)) {
-                    return res.status(403).json({ error: 'Access denied' });
-                }
-                const entries = await fs_extra_1.default.readdir(targetPath, { withFileTypes: true });
-                const files = entries
-                    .filter(dirent => dirent.isFile())
-                    .map(dirent => dirent.name);
-                const directories = entries
-                    .filter(dirent => dirent.isDirectory())
-                    .map(dirent => dirent.name);
-                res.json({
-                    files,
-                    directories,
-                    currentPath: path_1.default.relative(rootDir, targetPath),
-                    rootDir
-                });
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                const statusCode = error.code === 'ENOENT' ? 404 : 500;
-                res.status(statusCode).json({ error: message });
-            }
-        });
-        router.get('/download', async (req, res) => {
-            try {
-                const relativePath = req.query.path;
-                if (!relativePath) {
-                    return res.status(400).json({ error: 'Path parameter is required' });
-                }
-                const targetPath = path_1.default.join(rootDir, relativePath);
-                // Security: Ensure targetPath is within rootDir
-                if (!targetPath.startsWith(rootDir)) {
-                    return res.status(403).json({ error: 'Access denied' });
-                }
-                // Check if path exists and is a file
-                const stats = await fs_extra_1.default.stat(targetPath);
-                if (!stats.isFile()) {
-                    return res.status(404).json({ error: 'File not found' });
-                }
-                // Stream file for download
-                res.download(targetPath, path_1.default.basename(targetPath));
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                const statusCode = error.code === 'ENOENT' ? 404 : 500;
-                res.status(statusCode).json({ error: message });
-            }
-        });
-        router.get('/zip', async (req, res) => {
-            try {
-                const relativePath = req.query.path;
-                if (!relativePath) {
-                    return res.status(400).json({ error: 'Path parameter is required' });
-                }
-                const targetPath = path_1.default.join(rootDir, relativePath);
-                // Security: Ensure targetPath is within rootDir
-                if (!targetPath.startsWith(rootDir)) {
-                    return res.status(403).json({ error: 'Access denied' });
-                }
-                // Check if path exists and is a directory
-                const stats = await fs_extra_1.default.stat(targetPath);
-                if (!stats.isDirectory()) {
-                    return res.status(404).json({ error: 'Directory not found' });
-                }
-                // Set headers for ZIP download
-                res.attachment(`${path_1.default.basename(targetPath)}.zip`);
-                // Create ZIP stream
-                const archive = (0, archiver_1.default)('zip', {
-                    zlib: { level: 9 } // Maximum compression
-                });
-                archive.pipe(res);
-                archive.directory(targetPath, false);
-                await archive.finalize();
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                const statusCode = error.code === 'ENOENT' ? 404 : 500;
-                res.status(statusCode).json({ error: message });
-            }
-        });
-        context.addRouter('/files', router);
-    },
-};
-exports.default = plugin;

package/index.js

@@ -1,82 +0,0 @@
-"use strict";
-
-const express = require("express");
-const fs = require("fs-extra");
-const path = require("path");
-
-module.exports = (pluginContext) => {
-  const router = express.Router();
-
-  // Dynamic root lookup: Use Paperclip's workspace root
-  const rootDir = pluginContext.workspaceRoot || process.env.PAPERCLIP_WORKSPACE_ROOT || process.cwd();
-
-  /**
-   * GET /files/list
-   * List files and directories at the given path
-   */
-  router.get("/list", async (req, res) => {
-    const { dir } = req.query;
-    if (!dir) {
-      return res.status(400).json({ error: "Query parameter 'dir' is required" });
-    }
-
-    const targetPath = path.join(rootDir, dir);
-    try {
-      const stats = await fs.stat(targetPath);
-      if (!stats.isDirectory()) {
-        return res.status(400).json({ error: "Path is not a directory" });
-      }
-
-      const items = await fs.readdir(targetPath);
-      const detailedItems = await Promise.all(
-        items.map(async (item) => {
-          const itemPath = path.join(targetPath, item);
-          const itemStats = await fs.stat(itemPath);
-          return {
-            name: item,
-            path: path.relative(rootDir, itemPath),
-            isDirectory: itemStats.isDirectory(),
-            size: itemStats.size,
-            modified: itemStats.mtime
-          };
-        })
-      );
-
-      res.json({
-        path: dir,
-        items: detailedItems
-      });
-    } catch (error) {
-      res.status(500).json({ error: error.message });
-    }
-  });
-
-  /**
-   * GET /files/read
-   * Read file content
-   */
-  router.get("/read", async (req, res) => {
-    const { file } = req.query;
-    if (!file) {
-      return res.status(400).json({ error: "Query parameter 'file' is required" });
-    }
-
-    const filePath = path.join(rootDir, file);
-    try {
-      const stats = await fs.stat(filePath);
-      if (!stats.isFile()) {
-        return res.status(400).json({ error: "Path is not a file" });
-      }
-
-      const content = await fs.readFile(filePath, "utf-8");
-      res.json({
-        path: file,
-        content
-      });
-    } catch (error) {
-      res.status(500).json({ error: error.message });
-    }
-  });
-
-  return router;
-};

package/jest.config.js

@@ -1,6 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  testMatch: ['**/__tests__/**/*.spec.ts'],
-  moduleFileExtensions: ['ts', 'js', 'json', 'node'],
-};

package/manifest.ts

@@ -1,15 +0,0 @@
-import type { PaperclipPluginManifestV1 } from '@paperclipai/shared';
-
-export const manifest: PaperclipPluginManifestV1 = {
-  id: 'jkl.file-browser',
-  apiVersion: 1,
-  version: '1.0.0',
-  displayName: 'File Browser',
-  description: 'A plugin to browse files in the Paperclip workspace.',
-  author: 'JKL <support@jkl.co>',
-  categories: ['utilities'],
-  capabilities: [],
-  entrypoints: {
-    worker: 'dist/index.js',
-  },
-};

package/src/__tests__/file-browser.spec.ts

@@ -1,161 +0,0 @@
-import express from 'express';
-import request from 'supertest';
-import fs from 'fs-extra';
-import path from 'path';
-
-jest.mock('archiver', () => {
-  return jest.fn().mockImplementation(() => {
-    const { PassThrough } = require('stream');
-    const stream = new PassThrough();
-    setTimeout(() => { stream.end(); }, 50);
-    return {
-      pipe: (dest: NodeJS.WritableStream) => { stream.pipe(dest); return dest; },
-      directory: () => {},
-      finalize: jest.fn().mockResolvedValue(undefined),
-    };
-  });
-});
-
-import plugin from '../index';
-
-const mockRootDir = path.join(__dirname, 'mock-root');
-
-function createApp(): express.Express {
-  const app = express();
-  const routers: Array<{ basePath: string; router: express.Router }> = [];
-
-  const context = {
-    addRouter: (basePath: string, router: express.Router) => {
-      routers.push({ basePath, router });
-    },
-    environment: {
-      rootDir: mockRootDir,
-    },
-  };
-
-  plugin.register(context);
-
-  for (const { basePath, router } of routers) {
-    app.use(basePath, router);
-  }
-
-  return app;
-}
-
-describe('File Browser Plugin', () => {
-  let app: express.Express;
-  const mockFilePath = path.join(mockRootDir, 'test.txt');
-  const mockDirPath = path.join(mockRootDir, 'test-dir');
-  const mockNestedFilePath = path.join(mockDirPath, 'nested.txt');
-
-  beforeAll(async () => {
-    await fs.ensureDir(mockRootDir);
-    await fs.writeFile(mockFilePath, 'test content');
-    await fs.ensureDir(mockDirPath);
-    await fs.writeFile(mockNestedFilePath, 'nested content');
-    app = createApp();
-  });
-
-  afterAll(async () => {
-    await fs.remove(mockRootDir);
-  });
-
-  describe('Plugin registration', () => {
-    it('should throw if rootDir is invalid', () => {
-      const badContext = {
-        addRouter: () => {},
-        environment: { rootDir: '/nonexistent/path/that/does/not/exist' },
-      };
-      expect(() => plugin.register(badContext)).toThrow('Invalid root directory');
-    });
-
-    it('should register a router on /files', () => {
-      const registeredPaths: string[] = [];
-      const ctx = {
-        addRouter: (basePath: string) => { registeredPaths.push(basePath); },
-        environment: { rootDir: mockRootDir },
-      };
-      plugin.register(ctx);
-      expect(registeredPaths).toContain('/files');
-    });
-  });
-
-  describe('GET /files/list', () => {
-    it('should list files and directories in root', async () => {
-      const response = await request(app).get('/files/list');
-      expect(response.status).toBe(200);
-      expect(response.body.files).toContain('test.txt');
-      expect(response.body.directories).toContain('test-dir');
-      expect(response.body.currentPath).toBe('');
-    });
-
-    it('should list files and directories in subdirectory', async () => {
-      const response = await request(app).get('/files/list?path=test-dir');
-      expect(response.status).toBe(200);
-      expect(response.body.files).toContain('nested.txt');
-      expect(response.body.directories).toEqual([]);
-    });
-
-    it('should return 404 for non-existent directory', async () => {
-      const response = await request(app).get('/files/list?path=non-existent');
-      expect(response.status).toBe(404);
-    });
-
-    it('should return 403 for path traversal attempt', async () => {
-      const response = await request(app).get('/files/list?path=../../../etc');
-      expect(response.status).toBe(403);
-    });
-  });
-
-  describe('GET /files/download', () => {
-    it('should download a file', async () => {
-      const response = await request(app).get('/files/download?path=test.txt');
-      expect(response.status).toBe(200);
-      expect(response.text).toBe('test content');
-    });
-
-    it('should return 400 when path is missing', async () => {
-      const response = await request(app).get('/files/download');
-      expect(response.status).toBe(400);
-      expect(response.body.error).toBe('Path parameter is required');
-    });
-
-    it('should return 404 for non-existent file', async () => {
-      const response = await request(app).get('/files/download?path=non-existent.txt');
-      expect(response.status).toBe(404);
-    });
-
-    it('should return 403 for path traversal attempt', async () => {
-      const response = await request(app).get('/files/download?path=../../../etc/passwd');
-      expect(response.status).toBe(403);
-    });
-  });
-
-  describe('GET /files/zip', () => {
-    it('should return a zip response for a valid directory', async () => {
-      const response = await request(app).get('/files/zip?path=test-dir');
-      expect(response.status).toBe(200);
-    });
-
-    it('should return 400 when path is missing', async () => {
-      const response = await request(app).get('/files/zip');
-      expect(response.status).toBe(400);
-      expect(response.body.error).toBe('Path parameter is required');
-    });
-
-    it('should return 404 for non-existent directory', async () => {
-      const response = await request(app).get('/files/zip?path=non-existent');
-      expect(response.status).toBe(404);
-    });
-
-    it('should return 404 when path points to a file', async () => {
-      const response = await request(app).get('/files/zip?path=test.txt');
-      expect(response.status).toBe(404);
-    });
-
-    it('should return 403 for path traversal attempt', async () => {
-      const response = await request(app).get('/files/zip?path=../../../etc');
-      expect(response.status).toBe(403);
-    });
-  });
-});