@hamak/filesystem-server-impl 0.4.8

package/dist/es2015/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @hamak/filesystem-server-impl
+ *
+ * Backend filesystem server implementation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Export plugin (main entry point)
+__exportStar(require("./plugin/filesystem-server-plugin"), exports);
+// Export services
+__exportStar(require("./services/workspace-manager"), exports);
+// Export routing
+__exportStar(require("./routing/create-router"), exports);
+__exportStar(require("./routing/file-router"), exports);
+// Export middleware
+__exportStar(require("./middleware/workspace-validator"), exports);
+// Re-export API types for convenience
+__exportStar(require("@hamak/filesystem-server-api"), exports);

package/dist/es2015/middleware/workspace-validator.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Workspace Validator Middleware
+ *
+ * Validates workspace ID exists in configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkspaceValidator = void 0;
+/**
+ * Create middleware to validate workspace exists
+ *
+ * @param config - Server configuration with workspaces map
+ * @returns Express middleware function
+ */
+function createWorkspaceValidator(config) {
+    const workspaces = config.workspaces;
+    return (req, res, next) => {
+        const workspace = req.params.workspace;
+        if (!workspace) {
+            return res.status(400).json({ error: 'Workspace ID is required' });
+        }
+        if (!workspaces[workspace]) {
+            return res.status(404).json({ error: `Workspace '${workspace}' not found` });
+        }
+        // Store workspace info in request for downstream handlers
+        req.workspaceId = workspace;
+        req.workspacePath = workspaces[workspace];
+        next();
+    };
+}
+exports.createWorkspaceValidator = createWorkspaceValidator;

package/dist/es2015/plugin/filesystem-server-plugin.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * FileSystem Server Plugin
+ *
+ * Microkernel plugin for backend filesystem server
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemServerPlugin = exports.FileSystemServerPlugin = void 0;
+const filesystem_server_api_1 = require("@hamak/filesystem-server-api");
+const workspace_manager_1 = require("../services/workspace-manager");
+const create_router_1 = require("../routing/create-router");
+/**
+ * FileSystem Server Plugin Implementation
+ *
+ * Provides backend filesystem operations via Express routes
+ */
+class FileSystemServerPlugin {
+    /**
+     * Initialize phase - register services in DI container
+     */
+    initialize(ctx) {
+        console.log('[FileSystemServerPlugin] Initializing...');
+        // Resolve configuration
+        const config = ctx.resolve(filesystem_server_api_1.FILESYSTEM_SERVER_CONFIG_TOKEN);
+        // Create and register WorkspaceManager service
+        const workspaceManager = new workspace_manager_1.WorkspaceManager(config.workspaces, {
+            baseDirectory: config.baseDirectory,
+        });
+        ctx.provide({
+            provide: filesystem_server_api_1.WORKSPACE_MANAGER_TOKEN,
+            useValue: workspaceManager,
+        });
+        console.log('[FileSystemServerPlugin] WorkspaceManager service registered');
+        console.log(`[FileSystemServerPlugin] Base directory: ${config.baseDirectory}`);
+        console.log(`[FileSystemServerPlugin] Workspaces:`, Object.keys(config.workspaces));
+    }
+    /**
+     * Activate phase - create router and make ready for use
+     */
+    activate(ctx) {
+        var _a;
+        console.log('[FileSystemServerPlugin] Activating...');
+        // Resolve dependencies
+        const workspaceManager = ctx.resolve(filesystem_server_api_1.WORKSPACE_MANAGER_TOKEN);
+        const config = ctx.resolve(filesystem_server_api_1.FILESYSTEM_SERVER_CONFIG_TOKEN);
+        // Create Express router
+        this.router = (0, create_router_1.createFileSystemRouter)(workspaceManager, config);
+        // Note: Router is available via getRouter() method, not registered in DI
+        // This avoids circular dependencies and keeps the plugin self-contained
+        console.log('[FileSystemServerPlugin] Activated successfully');
+        console.log(`[FileSystemServerPlugin] Mount path: ${(_a = config.mountPath) !== null && _a !== void 0 ? _a : '/api/workspaces'}`);
+    }
+    /**
+     * Deactivate phase - cleanup
+     */
+    deactivate() {
+        console.log('[FileSystemServerPlugin] Deactivating...');
+        this.router = undefined;
+    }
+    /**
+     * Get the Express router for mounting in application
+     *
+     * @returns Express router with filesystem routes
+     * @throws Error if plugin not activated
+     */
+    getRouter() {
+        if (!this.router) {
+            throw new Error('[FileSystemServerPlugin] Plugin not activated. Call kernel.activate() first.');
+        }
+        return this.router;
+    }
+}
+exports.FileSystemServerPlugin = FileSystemServerPlugin;
+/**
+ * Factory function to create plugin instance
+ *
+ * @returns FileSystemServerPlugin instance
+ */
+function createFileSystemServerPlugin() {
+    return new FileSystemServerPlugin();
+}
+exports.createFileSystemServerPlugin = createFileSystemServerPlugin;

package/dist/es2015/routing/create-router.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Router Factory
+ *
+ * Creates and configures the Express router for filesystem operations
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemRouter = void 0;
+const express_1 = require("express");
+const cors_1 = __importDefault(require("cors"));
+const body_parser_1 = __importDefault(require("body-parser"));
+const filesystem_server_api_1 = require("@hamak/filesystem-server-api");
+const file_router_1 = require("./file-router");
+/**
+ * Create filesystem Express router with middleware
+ *
+ * @param workspaceManager - Workspace manager instance
+ * @param config - Server configuration
+ * @returns Configured Express router
+ */
+function createFileSystemRouter(workspaceManager, config) {
+    var _a, _b;
+    const app = (0, express_1.Router)();
+    // Apply CORS middleware if enabled
+    if ((_a = config.enableCors) !== null && _a !== void 0 ? _a : filesystem_server_api_1.DEFAULT_FILESYSTEM_SERVER_CONFIG.enableCors) {
+        app.use((0, cors_1.default)());
+    }
+    // Apply body parser for JSON payloads
+    app.use(body_parser_1.default.json());
+    // Create and mount file router
+    const fileRouter = new file_router_1.FileRouter(workspaceManager);
+    const mountPath = (_b = config.mountPath) !== null && _b !== void 0 ? _b : filesystem_server_api_1.DEFAULT_FILESYSTEM_SERVER_CONFIG.mountPath;
+    app.use(mountPath, fileRouter.router);
+    return app;
+}
+exports.createFileSystemRouter = createFileSystemRouter;

package/dist/es2015/routing/file-router.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * File Router
+ *
+ * Express routes for filesystem operations
+ * Migrated from amk/libs/server/ws/ws-server
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRouter = void 0;
+const express_1 = require("express");
+class FileRouter {
+    constructor(workspaceManager) {
+        this.router = (0, express_1.Router)();
+        this.workspaceManager = workspaceManager;
+        this.initializeRoutes();
+    }
+    initializeRoutes() {
+        this.router.get('/:workspace/files/*', this.listFiles.bind(this));
+        this.router.post('/:workspace/mkdir/*', this.createDirectory.bind(this));
+        this.router.get('/:workspace/get/*', this.getFile.bind(this));
+        this.router.get('/:workspace/read/*', this.readFile.bind(this));
+        this.router.post('/:workspace/post/*', this.writeFile.bind(this));
+        this.router.put('/:workspace/put/*', this.writeFile.bind(this));
+        this.router.delete('/:workspace/delete/*', this.deleteFile.bind(this));
+    }
+    parsePath(pathString) {
+        // Split path string into segments, filter out empty segments
+        return pathString.split('/').filter(seg => seg.length > 0);
+    }
+    listFiles(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { workspace } = req.params;
+                const pathSegments = this.parsePath(req.params[0] || '');
+                const files = yield this.workspaceManager.listFiles(workspace, pathSegments);
+                res.json(files);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+    createDirectory(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { workspace } = req.params;
+                const pathSegments = this.parsePath(req.params[0] || '');
+                const dirInfo = yield this.workspaceManager.createDirectory(workspace, pathSegments);
+                res.json(dirInfo);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+    getFile(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { workspace } = req.params;
+                const pathSegments = this.parsePath(req.params[0] || '');
+                const fileInfo = yield this.workspaceManager.getFile(workspace, pathSegments);
+                res.json(fileInfo);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+    readFile(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { workspace } = req.params;
+                const pathSegments = this.parsePath(req.params[0] || '');
+                const fileInfo = yield this.workspaceManager.readFile(workspace, pathSegments);
+                res.json(fileInfo);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+    writeFile(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { workspace } = req.params;
+                const pathSegments = this.parsePath(req.params[0] || '');
+                const { content } = req.body;
+                const fileInfo = yield this.workspaceManager.writeFile(workspace, pathSegments, content);
+                res.json(fileInfo);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+    deleteFile(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { workspace } = req.params;
+                const pathSegments = this.parsePath(req.params[0] || '');
+                const fileInfo = yield this.workspaceManager.deleteFile(workspace, pathSegments);
+                res.json(fileInfo);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+}
+exports.FileRouter = FileRouter;

package/dist/es2015/services/workspace-manager.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Workspace Manager Implementation
+ *
+ * Provides filesystem operations for workspace-based storage
+ * Migrated from amk/libs/server/ws/ws-server
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceManager = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+class WorkspaceManager {
+    constructor(workspaces, options) {
+        this.workspaces = workspaces;
+        this.options = options;
+    }
+    resolvePath(workspace, filePath) {
+        const basePath = path.resolve(this.options.baseDirectory, this.workspaces[workspace]);
+        if (!basePath) {
+            throw new Error(`Workspace ${workspace} not found`);
+        }
+        const relativePath = Array.isArray(filePath) ? filePath.join(path.sep) : filePath;
+        return path.resolve(basePath, relativePath);
+    }
+    listFiles(workspace, filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const absolutePath = this.resolvePath(workspace, filePath);
+            const files = yield fs_1.promises.readdir(absolutePath, { withFileTypes: true });
+            const fileInfos = yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () {
+                const fullPath = path.join(absolutePath, file.name);
+                const stats = yield fs_1.promises.stat(fullPath);
+                return {
+                    name: file.name,
+                    path: fullPath,
+                    isDirectory: file.isDirectory(),
+                    size: stats.size,
+                    createdAt: stats.birthtime,
+                    updatedAt: stats.mtime,
+                };
+            })));
+            return fileInfos;
+        });
+    }
+    createDirectory(workspace, filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const absolutePath = this.resolvePath(workspace, filePath);
+            yield fs_1.promises.mkdir(absolutePath, { recursive: true });
+            const stats = yield fs_1.promises.stat(absolutePath);
+            return {
+                name: path.basename(absolutePath),
+                path: absolutePath,
+                isDirectory: true,
+                size: stats.size,
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
+            };
+        });
+    }
+    getFile(workspace, filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const absolutePath = this.resolvePath(workspace, filePath);
+            const stats = yield fs_1.promises.stat(absolutePath);
+            if (stats.isDirectory()) {
+                throw new Error('Path is a directory');
+            }
+            return {
+                name: path.basename(absolutePath),
+                path: absolutePath,
+                isDirectory: false,
+                size: stats.size,
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
+            };
+        });
+    }
+    readFile(workspace, filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const absolutePath = this.resolvePath(workspace, filePath);
+            const data = yield fs_1.promises.readFile(absolutePath, 'utf-8');
+            const stats = yield fs_1.promises.stat(absolutePath);
+            return {
+                name: path.basename(absolutePath),
+                path: absolutePath,
+                isDirectory: false,
+                size: stats.size,
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
+                content: data, // Include file content
+            };
+        });
+    }
+    writeFile(workspace, filePath, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const absolutePath = this.resolvePath(workspace, filePath);
+            const data = typeof content === "string" ? content : JSON.stringify(content !== null && content !== void 0 ? content : "");
+            yield fs_1.promises.writeFile(absolutePath, data);
+            const stats = yield fs_1.promises.stat(absolutePath);
+            return {
+                name: path.basename(absolutePath),
+                path: absolutePath,
+                isDirectory: false,
+                size: stats.size,
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
+            };
+        });
+    }
+    deleteFile(workspace, filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const absolutePath = this.resolvePath(workspace, filePath);
+            const stats = yield fs_1.promises.stat(absolutePath);
+            yield fs_1.promises.rm(absolutePath, { recursive: true, force: true });
+            return {
+                name: path.basename(absolutePath),
+                path: absolutePath,
+                isDirectory: stats.isDirectory(),
+                size: stats.size,
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
+            };
+        });
+    }
+}
+exports.WorkspaceManager = WorkspaceManager;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hamak/filesystem-server-impl
+ *
+ * Backend filesystem server implementation
+ */
+export * from './plugin/filesystem-server-plugin';
+export * from './services/workspace-manager';
+export * from './routing/create-router';
+export * from './routing/file-router';
+export * from './middleware/workspace-validator';
+export * from '@hamak/filesystem-server-api';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,mCAAmC,CAAC;AAGlD,cAAc,8BAA8B,CAAC;AAG7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,kCAAkC,CAAC;AAGjD,cAAc,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * @hamak/filesystem-server-impl
+ *
+ * Backend filesystem server implementation
+ */
+// Export plugin (main entry point)
+export * from './plugin/filesystem-server-plugin';
+// Export services
+export * from './services/workspace-manager';
+// Export routing
+export * from './routing/create-router';
+export * from './routing/file-router';
+// Export middleware
+export * from './middleware/workspace-validator';
+// Re-export API types for convenience
+export * from '@hamak/filesystem-server-api';

package/dist/middleware/workspace-validator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Workspace Validator Middleware
+ *
+ * Validates workspace ID exists in configuration
+ */
+import { Request, Response, NextFunction } from 'express';
+import { FileSystemServerConfig } from '@hamak/filesystem-server-api';
+/**
+ * Create middleware to validate workspace exists
+ *
+ * @param config - Server configuration with workspaces map
+ * @returns Express middleware function
+ */
+export declare function createWorkspaceValidator(config: FileSystemServerConfig): (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;
+//# sourceMappingURL=workspace-validator.d.ts.map

package/dist/middleware/workspace-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-validator.d.ts","sourceRoot":"","sources":["../../src/middleware/workspace-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAEtE;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,sBAAsB,SAGxD,OAAO,OAAO,QAAQ,QAAQ,YAAY,oDAiBxD"}

package/dist/middleware/workspace-validator.js

@@ -0,0 +1,27 @@
+/**
+ * Workspace Validator Middleware
+ *
+ * Validates workspace ID exists in configuration
+ */
+/**
+ * Create middleware to validate workspace exists
+ *
+ * @param config - Server configuration with workspaces map
+ * @returns Express middleware function
+ */
+export function createWorkspaceValidator(config) {
+    const workspaces = config.workspaces;
+    return (req, res, next) => {
+        const workspace = req.params.workspace;
+        if (!workspace) {
+            return res.status(400).json({ error: 'Workspace ID is required' });
+        }
+        if (!workspaces[workspace]) {
+            return res.status(404).json({ error: `Workspace '${workspace}' not found` });
+        }
+        // Store workspace info in request for downstream handlers
+        req.workspaceId = workspace;
+        req.workspacePath = workspaces[workspace];
+        next();
+    };
+}

package/dist/plugin/filesystem-server-plugin.d.ts

@@ -0,0 +1,42 @@
+/**
+ * FileSystem Server Plugin
+ *
+ * Microkernel plugin for backend filesystem server
+ */
+import { Router } from 'express';
+import { PluginModule, InitializationContext } from '@hamak/microkernel-spi';
+import { ActivateContext } from '@hamak/microkernel-api';
+/**
+ * FileSystem Server Plugin Implementation
+ *
+ * Provides backend filesystem operations via Express routes
+ */
+export declare class FileSystemServerPlugin implements PluginModule {
+    private router?;
+    /**
+     * Initialize phase - register services in DI container
+     */
+    initialize(ctx: InitializationContext): void;
+    /**
+     * Activate phase - create router and make ready for use
+     */
+    activate(ctx: ActivateContext): void;
+    /**
+     * Deactivate phase - cleanup
+     */
+    deactivate(): void;
+    /**
+     * Get the Express router for mounting in application
+     *
+     * @returns Express router with filesystem routes
+     * @throws Error if plugin not activated
+     */
+    getRouter(): Router;
+}
+/**
+ * Factory function to create plugin instance
+ *
+ * @returns FileSystemServerPlugin instance
+ */
+export declare function createFileSystemServerPlugin(): PluginModule;
+//# sourceMappingURL=filesystem-server-plugin.d.ts.map

package/dist/plugin/filesystem-server-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-server-plugin.d.ts","sourceRoot":"","sources":["../../src/plugin/filesystem-server-plugin.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAWzD;;;;GAIG;AACH,qBAAa,sBAAuB,YAAW,YAAY;IACzD,OAAO,CAAC,MAAM,CAAC,CAAS;IAExB;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE,qBAAqB,GAAG,IAAI;IAqB5C;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI;IAiBpC;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;;;;OAKG;IACH,SAAS,IAAI,MAAM;CAQpB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,YAAY,CAE3D"}

package/dist/plugin/filesystem-server-plugin.js

@@ -0,0 +1,76 @@
+/**
+ * FileSystem Server Plugin
+ *
+ * Microkernel plugin for backend filesystem server
+ */
+import { FILESYSTEM_SERVER_CONFIG_TOKEN, WORKSPACE_MANAGER_TOKEN, } from '@hamak/filesystem-server-api';
+import { WorkspaceManager } from '../services/workspace-manager';
+import { createFileSystemRouter } from '../routing/create-router';
+/**
+ * FileSystem Server Plugin Implementation
+ *
+ * Provides backend filesystem operations via Express routes
+ */
+export class FileSystemServerPlugin {
+    /**
+     * Initialize phase - register services in DI container
+     */
+    initialize(ctx) {
+        console.log('[FileSystemServerPlugin] Initializing...');
+        // Resolve configuration
+        const config = ctx.resolve(FILESYSTEM_SERVER_CONFIG_TOKEN);
+        // Create and register WorkspaceManager service
+        const workspaceManager = new WorkspaceManager(config.workspaces, {
+            baseDirectory: config.baseDirectory,
+        });
+        ctx.provide({
+            provide: WORKSPACE_MANAGER_TOKEN,
+            useValue: workspaceManager,
+        });
+        console.log('[FileSystemServerPlugin] WorkspaceManager service registered');
+        console.log(`[FileSystemServerPlugin] Base directory: ${config.baseDirectory}`);
+        console.log(`[FileSystemServerPlugin] Workspaces:`, Object.keys(config.workspaces));
+    }
+    /**
+     * Activate phase - create router and make ready for use
+     */
+    activate(ctx) {
+        console.log('[FileSystemServerPlugin] Activating...');
+        // Resolve dependencies
+        const workspaceManager = ctx.resolve(WORKSPACE_MANAGER_TOKEN);
+        const config = ctx.resolve(FILESYSTEM_SERVER_CONFIG_TOKEN);
+        // Create Express router
+        this.router = createFileSystemRouter(workspaceManager, config);
+        // Note: Router is available via getRouter() method, not registered in DI
+        // This avoids circular dependencies and keeps the plugin self-contained
+        console.log('[FileSystemServerPlugin] Activated successfully');
+        console.log(`[FileSystemServerPlugin] Mount path: ${config.mountPath ?? '/api/workspaces'}`);
+    }
+    /**
+     * Deactivate phase - cleanup
+     */
+    deactivate() {
+        console.log('[FileSystemServerPlugin] Deactivating...');
+        this.router = undefined;
+    }
+    /**
+     * Get the Express router for mounting in application
+     *
+     * @returns Express router with filesystem routes
+     * @throws Error if plugin not activated
+     */
+    getRouter() {
+        if (!this.router) {
+            throw new Error('[FileSystemServerPlugin] Plugin not activated. Call kernel.activate() first.');
+        }
+        return this.router;
+    }
+}
+/**
+ * Factory function to create plugin instance
+ *
+ * @returns FileSystemServerPlugin instance
+ */
+export function createFileSystemServerPlugin() {
+    return new FileSystemServerPlugin();
+}

package/dist/routing/create-router.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Router Factory
+ *
+ * Creates and configures the Express router for filesystem operations
+ */
+import { Router } from 'express';
+import { IWorkspaceManager, FileSystemServerConfig } from '@hamak/filesystem-server-api';
+/**
+ * Create filesystem Express router with middleware
+ *
+ * @param workspaceManager - Workspace manager instance
+ * @param config - Server configuration
+ * @returns Configured Express router
+ */
+export declare function createFileSystemRouter(workspaceManager: IWorkspaceManager, config: FileSystemServerConfig): Router;
+//# sourceMappingURL=create-router.d.ts.map

package/dist/routing/create-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-router.d.ts","sourceRoot":"","sources":["../../src/routing/create-router.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjC,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAoC,MAAM,8BAA8B,CAAC;AAG3H;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,iBAAiB,EACnC,MAAM,EAAE,sBAAsB,GAC7B,MAAM,CAiBR"}

package/dist/routing/create-router.js

@@ -0,0 +1,31 @@
+/**
+ * Router Factory
+ *
+ * Creates and configures the Express router for filesystem operations
+ */
+import { Router } from 'express';
+import cors from 'cors';
+import bodyParser from 'body-parser';
+import { DEFAULT_FILESYSTEM_SERVER_CONFIG } from '@hamak/filesystem-server-api';
+import { FileRouter } from './file-router';
+/**
+ * Create filesystem Express router with middleware
+ *
+ * @param workspaceManager - Workspace manager instance
+ * @param config - Server configuration
+ * @returns Configured Express router
+ */
+export function createFileSystemRouter(workspaceManager, config) {
+    const app = Router();
+    // Apply CORS middleware if enabled
+    if (config.enableCors ?? DEFAULT_FILESYSTEM_SERVER_CONFIG.enableCors) {
+        app.use(cors());
+    }
+    // Apply body parser for JSON payloads
+    app.use(bodyParser.json());
+    // Create and mount file router
+    const fileRouter = new FileRouter(workspaceManager);
+    const mountPath = config.mountPath ?? DEFAULT_FILESYSTEM_SERVER_CONFIG.mountPath;
+    app.use(mountPath, fileRouter.router);
+    return app;
+}

package/dist/routing/file-router.d.ts

@@ -0,0 +1,22 @@
+/**
+ * File Router
+ *
+ * Express routes for filesystem operations
+ * Migrated from amk/libs/server/ws/ws-server
+ */
+import { Router } from 'express';
+import { IWorkspaceManager } from '@hamak/filesystem-server-api';
+export declare class FileRouter {
+    router: Router;
+    private workspaceManager;
+    constructor(workspaceManager: IWorkspaceManager);
+    private initializeRoutes;
+    private parsePath;
+    private listFiles;
+    private createDirectory;
+    private getFile;
+    private readFile;
+    private writeFile;
+    private deleteFile;
+}
+//# sourceMappingURL=file-router.d.ts.map

package/dist/routing/file-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-router.d.ts","sourceRoot":"","sources":["../../src/routing/file-router.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAqB,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEjE,qBAAa,UAAU;IACd,MAAM,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,gBAAgB,CAAoB;gBAEhC,gBAAgB,EAAE,iBAAiB;IAM/C,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,SAAS;YAKH,SAAS;YAWT,eAAe;YAWf,OAAO;YAWP,QAAQ;YAWR,SAAS;YAYT,UAAU;CAUzB"}

package/dist/routing/file-router.js

@@ -0,0 +1,94 @@
+/**
+ * File Router
+ *
+ * Express routes for filesystem operations
+ * Migrated from amk/libs/server/ws/ws-server
+ */
+import { Router } from 'express';
+export class FileRouter {
+    constructor(workspaceManager) {
+        this.router = Router();
+        this.workspaceManager = workspaceManager;
+        this.initializeRoutes();
+    }
+    initializeRoutes() {
+        this.router.get('/:workspace/files/*', this.listFiles.bind(this));
+        this.router.post('/:workspace/mkdir/*', this.createDirectory.bind(this));
+        this.router.get('/:workspace/get/*', this.getFile.bind(this));
+        this.router.get('/:workspace/read/*', this.readFile.bind(this));
+        this.router.post('/:workspace/post/*', this.writeFile.bind(this));
+        this.router.put('/:workspace/put/*', this.writeFile.bind(this));
+        this.router.delete('/:workspace/delete/*', this.deleteFile.bind(this));
+    }
+    parsePath(pathString) {
+        // Split path string into segments, filter out empty segments
+        return pathString.split('/').filter(seg => seg.length > 0);
+    }
+    async listFiles(req, res) {
+        try {
+            const { workspace } = req.params;
+            const pathSegments = this.parsePath(req.params[0] || '');
+            const files = await this.workspaceManager.listFiles(workspace, pathSegments);
+            res.json(files);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    }
+    async createDirectory(req, res) {
+        try {
+            const { workspace } = req.params;
+            const pathSegments = this.parsePath(req.params[0] || '');
+            const dirInfo = await this.workspaceManager.createDirectory(workspace, pathSegments);
+            res.json(dirInfo);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    }
+    async getFile(req, res) {
+        try {
+            const { workspace } = req.params;
+            const pathSegments = this.parsePath(req.params[0] || '');
+            const fileInfo = await this.workspaceManager.getFile(workspace, pathSegments);
+            res.json(fileInfo);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    }
+    async readFile(req, res) {
+        try {
+            const { workspace } = req.params;
+            const pathSegments = this.parsePath(req.params[0] || '');
+            const fileInfo = await this.workspaceManager.readFile(workspace, pathSegments);
+            res.json(fileInfo);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    }
+    async writeFile(req, res) {
+        try {
+            const { workspace } = req.params;
+            const pathSegments = this.parsePath(req.params[0] || '');
+            const { content } = req.body;
+            const fileInfo = await this.workspaceManager.writeFile(workspace, pathSegments, content);
+            res.json(fileInfo);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    }
+    async deleteFile(req, res) {
+        try {
+            const { workspace } = req.params;
+            const pathSegments = this.parsePath(req.params[0] || '');
+            const fileInfo = await this.workspaceManager.deleteFile(workspace, pathSegments);
+            res.json(fileInfo);
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    }
+}

package/dist/services/workspace-manager.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Workspace Manager Implementation
+ *
+ * Provides filesystem operations for workspace-based storage
+ * Migrated from amk/libs/server/ws/ws-server
+ */
+import { FileInfo } from '@hamak/shared-utils';
+import { IWorkspaceManager } from '@hamak/filesystem-server-api';
+export interface WorkspaceManagerOptions {
+    baseDirectory: string;
+}
+export declare class WorkspaceManager implements IWorkspaceManager {
+    private workspaces;
+    private options;
+    constructor(workspaces: Record<string, string>, options: WorkspaceManagerOptions);
+    private resolvePath;
+    listFiles(workspace: string, filePath: string | string[]): Promise<FileInfo[]>;
+    createDirectory(workspace: string, filePath: string | string[]): Promise<FileInfo>;
+    getFile(workspace: string, filePath: string | string[]): Promise<FileInfo>;
+    readFile(workspace: string, filePath: string | string[]): Promise<FileInfo>;
+    writeFile(workspace: string, filePath: string | string[], content: string): Promise<FileInfo>;
+    deleteFile(workspace: string, filePath: string | string[]): Promise<FileInfo>;
+}
+//# sourceMappingURL=workspace-manager.d.ts.map

package/dist/services/workspace-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-manager.d.ts","sourceRoot":"","sources":["../../src/services/workspace-manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGjE,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,gBAAiB,YAAW,iBAAiB;IACxD,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,OAAO,CAA0B;gBAE7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,uBAAuB;IAKhF,OAAO,CAAC,WAAW;IASN,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAoB9E,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;IAclF,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;IAgB1E,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;IAgB3E,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAe7F,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;CAa3F"}

package/dist/services/workspace-manager.js

@@ -0,0 +1,108 @@
+/**
+ * Workspace Manager Implementation
+ *
+ * Provides filesystem operations for workspace-based storage
+ * Migrated from amk/libs/server/ws/ws-server
+ */
+import { promises as fs } from 'fs';
+import * as path from 'path';
+export class WorkspaceManager {
+    constructor(workspaces, options) {
+        this.workspaces = workspaces;
+        this.options = options;
+    }
+    resolvePath(workspace, filePath) {
+        const basePath = path.resolve(this.options.baseDirectory, this.workspaces[workspace]);
+        if (!basePath) {
+            throw new Error(`Workspace ${workspace} not found`);
+        }
+        const relativePath = Array.isArray(filePath) ? filePath.join(path.sep) : filePath;
+        return path.resolve(basePath, relativePath);
+    }
+    async listFiles(workspace, filePath) {
+        const absolutePath = this.resolvePath(workspace, filePath);
+        const files = await fs.readdir(absolutePath, { withFileTypes: true });
+        const fileInfos = await Promise.all(files.map(async (file) => {
+            const fullPath = path.join(absolutePath, file.name);
+            const stats = await fs.stat(fullPath);
+            return {
+                name: file.name,
+                path: fullPath,
+                isDirectory: file.isDirectory(),
+                size: stats.size,
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
+            };
+        }));
+        return fileInfos;
+    }
+    async createDirectory(workspace, filePath) {
+        const absolutePath = this.resolvePath(workspace, filePath);
+        await fs.mkdir(absolutePath, { recursive: true });
+        const stats = await fs.stat(absolutePath);
+        return {
+            name: path.basename(absolutePath),
+            path: absolutePath,
+            isDirectory: true,
+            size: stats.size,
+            createdAt: stats.birthtime,
+            updatedAt: stats.mtime,
+        };
+    }
+    async getFile(workspace, filePath) {
+        const absolutePath = this.resolvePath(workspace, filePath);
+        const stats = await fs.stat(absolutePath);
+        if (stats.isDirectory()) {
+            throw new Error('Path is a directory');
+        }
+        return {
+            name: path.basename(absolutePath),
+            path: absolutePath,
+            isDirectory: false,
+            size: stats.size,
+            createdAt: stats.birthtime,
+            updatedAt: stats.mtime,
+        };
+    }
+    async readFile(workspace, filePath) {
+        const absolutePath = this.resolvePath(workspace, filePath);
+        const data = await fs.readFile(absolutePath, 'utf-8');
+        const stats = await fs.stat(absolutePath);
+        return {
+            name: path.basename(absolutePath),
+            path: absolutePath,
+            isDirectory: false,
+            size: stats.size,
+            createdAt: stats.birthtime,
+            updatedAt: stats.mtime,
+            content: data, // Include file content
+        };
+    }
+    async writeFile(workspace, filePath, content) {
+        const absolutePath = this.resolvePath(workspace, filePath);
+        const data = typeof content === "string" ? content : JSON.stringify(content ?? "");
+        await fs.writeFile(absolutePath, data);
+        const stats = await fs.stat(absolutePath);
+        return {
+            name: path.basename(absolutePath),
+            path: absolutePath,
+            isDirectory: false,
+            size: stats.size,
+            createdAt: stats.birthtime,
+            updatedAt: stats.mtime,
+        };
+    }
+    async deleteFile(workspace, filePath) {
+        const absolutePath = this.resolvePath(workspace, filePath);
+        const stats = await fs.stat(absolutePath);
+        await fs.rm(absolutePath, { recursive: true, force: true });
+        return {
+            name: path.basename(absolutePath),
+            path: absolutePath,
+            isDirectory: stats.isDirectory(),
+            size: stats.size,
+            createdAt: stats.birthtime,
+            updatedAt: stats.mtime,
+        };
+    }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@hamak/filesystem-server-impl",
+  "version": "0.4.8",
+  "private": false,
+  "type": "module",
+  "description": "FileSystem Server Implementation - Backend filesystem server with Express routes",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amah/app-framework.git",
+    "directory": "packages/backend/filesystem-server/filesystem-server-impl"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.es2015.json",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/es2015/index.js",
+      "default": "./dist/index.js"
+    },
+    "./es2015": {
+      "require": "./dist/es2015/index.js",
+      "default": "./dist/es2015/index.js"
+    }
+  },
+  "dependencies": {
+    "@hamak/filesystem-server-api": "0.4.7",
+    "@hamak/filesystem-server-spi": "0.4.7",
+    "@hamak/microkernel-api": "0.4.7",
+    "@hamak/microkernel-spi": "0.4.7",
+    "@hamak/shared-utils": "0.4.7",
+    "cors": "^2.8.5",
+    "express": "^4.18.0"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.0",
+    "@types/express": "^4.17.0",
+    "typescript": "~5.4.0",
+    "vitest": "^2.0.0"
+  }
+}