@hamak/ui-remote-fs-impl 0.4.3

package/dist/middleware/store-sync-middleware.js

@@ -0,0 +1,134 @@
+/**
+ * Store Sync Middleware
+ *
+ * Redux middleware for synchronizing remote filesystem operations to Redux Store FS.
+ * This middleware listens to remote FS completion actions and updates the Store FS accordingly.
+ * Migrated from amk/libs/ui/core/remote-fs/src/lib/store-fs-adapter-middleware.ts
+ */
+import { Pathway } from '@hamak/shared-utils';
+import { RemoteFsActionTypes } from '@hamak/ui-remote-fs-api';
+import { rfsActions, } from '../actions/remote-fs-actions';
+/**
+ * Create store sync middleware
+ *
+ * This middleware intercepts remote FS completion actions and synchronizes them
+ * to the Redux Store FileSystem. It handles:
+ * - LS_COMPLETED: Creates directories and file entries in Store FS
+ * - MKDIR_COMPLETED: Creates directory in Store FS
+ * - GET_COMPLETED: Creates/updates file content in Store FS
+ * - POST/PUT_COMPLETED: Reloads file content from remote
+ * - DELETE_COMPLETED: Removes node from Store FS
+ *
+ * @param config Middleware configuration
+ * @returns Redux middleware
+ *
+ * @example
+ * ```typescript
+ * const middleware = createStoreSyncMiddleware({
+ *   fileSystemAdapter: storeFs,
+ *   pathTranslator: new PathTranslator(Pathway.ofRoot().resolve('remote')),
+ *   autoReload: true
+ * });
+ * ```
+ */
+export function createStoreSyncMiddleware(config) {
+    const { fileSystemAdapter, pathTranslator, autoReload = true, transformContent } = config;
+    const storeFsActions = fileSystemAdapter.getActions();
+    const storeSyncMiddleware = (store) => (next) => (action) => {
+        const result = next(action);
+        const anyAction = action;
+        // Only process remote FS actions
+        if (!rfsActions.isRemoteFsAction(anyAction)) {
+            return result;
+        }
+        const dispatch = store.dispatch;
+        switch (anyAction.type) {
+            case RemoteFsActionTypes.LS_COMPLETED: {
+                const completedAction = anyAction;
+                const { request, data } = completedAction.payload;
+                // Iterate through file list and create entries in Store FS
+                data?.forEach((fileInfo) => {
+                    // Build local path: request path + file name
+                    const localPath = Pathway.of(request.payload.path)
+                        .resolve(fileInfo.name)
+                        .getSegments();
+                    if (fileInfo.isDirectory) {
+                        // Create directory with parents flag
+                        dispatch(storeFsActions.mkdir(localPath, true));
+                    }
+                    else {
+                        // Create file entry without content (contentIsPresent: false)
+                        dispatch(storeFsActions.setFile(localPath, undefined, 'xs:any', {
+                            override: true,
+                            contentIsPresent: false,
+                        }));
+                    }
+                });
+                break;
+            }
+            case RemoteFsActionTypes.MKDIR_COMPLETED: {
+                const completedAction = anyAction;
+                const { request } = completedAction.payload;
+                const localPath = Pathway.of(request.payload.path).getSegments();
+                // Create directory in Store FS
+                dispatch(storeFsActions.mkdir(localPath, true));
+                break;
+            }
+            case RemoteFsActionTypes.GET_COMPLETED: {
+                const completedAction = anyAction;
+                const { request, data } = completedAction.payload;
+                const localPath = Pathway.of(request.payload.path).getSegments();
+                // Parse content
+                let content = data.content === undefined || data.content === null
+                    ? undefined
+                    : data.content === ''
+                        ? undefined
+                        : JSON.parse(data.content);
+                // Apply content transform if provided
+                if (content !== undefined && transformContent) {
+                    content = transformContent(content);
+                }
+                // Check if file exists in Store FS
+                const fileSystemNode = fileSystemAdapter.createSelector((state) => state.fileSystem, localPath)(store.getState());
+                if (fileSystemNode === undefined) {
+                    // File doesn't exist, create it with content
+                    dispatch(storeFsActions.setFile(localPath, content, 'xs:any', {
+                        override: true,
+                        contentIsPresent: true,
+                    }));
+                }
+                else {
+                    // File exists, update content only if it's a file
+                    if (fileSystemNode?.type === 'file') {
+                        dispatch(storeFsActions.setFileContent(localPath, content, true));
+                    }
+                }
+                break;
+            }
+            case RemoteFsActionTypes.POST_COMPLETED:
+            case RemoteFsActionTypes.PUT_COMPLETED: {
+                const completedAction = anyAction;
+                const { request } = completedAction.payload;
+                const localPath = Pathway.of(request.payload.path).getSegments();
+                // Reload file content from remote if autoReload is enabled
+                if (autoReload) {
+                    dispatch(rfsActions.ofGetRequest(localPath));
+                }
+                break;
+            }
+            case RemoteFsActionTypes.DELETE_COMPLETED: {
+                const completedAction = anyAction;
+                const { request } = completedAction.payload;
+                const localPath = Pathway.of(request.payload.path).getSegments();
+                // Remove node from Store FS
+                dispatch(storeFsActions.removeNode(localPath));
+                break;
+            }
+            default:
+                break;
+        }
+        return result;
+    };
+    return storeSyncMiddleware;
+}
+export default createStoreSyncMiddleware;

package/dist/plugin/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Remote FS Plugin Factory
+ */
+export * from './remote-fs-plugin-factory';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,4BAA4B,CAAC"}

package/dist/plugin/index.js

@@ -0,0 +1,4 @@
+/**
+ * Remote FS Plugin Factory
+ */
+export * from './remote-fs-plugin-factory';

package/dist/plugin/remote-fs-plugin-factory.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Remote FS Plugin Factory
+ *
+ * Creates a microkernel plugin for remote filesystem operations.
+ * Integrates HTTP-based remote filesystem with Redux Store FS.
+ */
+import type { PluginModule } from '@hamak/microkernel-spi';
+import type { Pathway } from '@hamak/shared-utils';
+import { IWorkspaceClient, IPathTranslator } from '@hamak/ui-remote-fs-spi';
+/**
+ * Configuration for Remote FS plugin
+ */
+export interface RemoteFsPluginConfig {
+    /**
+     * Workspace identifier
+     */
+    workspaceId: string;
+    /**
+     * Mount point for remote filesystem
+     * This is the local path where remote files will be mounted
+     * @example Pathway.ofRoot().resolve('remote')
+     */
+    mountPoint: Pathway;
+    /**
+     * Base URL for the workspace API
+     * If not provided, defaults to current origin + '/api'
+     * @example 'http://localhost:3000/api'
+     */
+    baseUrl?: string;
+    /**
+     * Request timeout in milliseconds
+     * Default: 30000 (30 seconds)
+     */
+    timeout?: number;
+    /**
+     * Whether to automatically reload file content after PUT/POST
+     * Default: true
+     */
+    autoReload?: boolean;
+    /**
+     * Optional transform function for file content before storing
+     */
+    transformContent?: (content: any) => any;
+    /**
+     * Enable development logging
+     * Default: false
+     */
+    debug?: boolean;
+    /**
+     * Custom workspace client (for testing or advanced scenarios)
+     */
+    customClient?: IWorkspaceClient;
+    /**
+     * Custom path translator (for advanced scenarios)
+     */
+    customPathTranslator?: IPathTranslator;
+}
+/**
+ * Create Remote FS plugin
+ *
+ * This plugin provides remote filesystem capabilities through HTTP API.
+ * It registers two middleware:
+ * - Remote FS Middleware: Handles remote operations via HTTP client
+ * - Store Sync Middleware: Synchronizes remote data to Redux Store FS
+ *
+ * @param config Plugin configuration
+ * @returns PluginModule for microkernel integration
+ *
+ * @example
+ * ```typescript
+ * import { Pathway } from '@hamak/shared-utils';
+ * import { createRemoteFsPlugin } from '@hamak/ui-remote-fs-impl';
+ *
+ * const plugin = createRemoteFsPlugin({
+ *   workspaceId: '0',
+ *   mountPoint: Pathway.ofRoot().resolve('remote'),
+ *   baseUrl: 'http://localhost:3000/api',
+ *   autoReload: true
+ * });
+ * ```
+ */
+export declare function createRemoteFsPlugin(config: RemoteFsPluginConfig): PluginModule;
+export default createRemoteFsPlugin;
+//# sourceMappingURL=remote-fs-plugin-factory.d.ts.map

package/dist/plugin/remote-fs-plugin-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-fs-plugin-factory.d.ts","sourceRoot":"","sources":["../../src/plugin/remote-fs-plugin-factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAMnD,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAkB,MAAM,yBAAyB,CAAC;AAU5F;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,CAAC;IAEzC;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAEhC;;OAEG;IACH,oBAAoB,CAAC,EAAE,eAAe,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,YAAY,CAkI/E;AAED,eAAe,oBAAoB,CAAC"}

package/dist/plugin/remote-fs-plugin-factory.js

@@ -0,0 +1,150 @@
+/**
+ * Remote FS Plugin Factory
+ *
+ * Creates a microkernel plugin for remote filesystem operations.
+ * Integrates HTTP-based remote filesystem with Redux Store FS.
+ */
+import { WORKSPACE_CLIENT_TOKEN, PATH_TRANSLATOR_TOKEN, } from '@hamak/ui-remote-fs-api';
+import { PathTranslator } from '@hamak/ui-remote-fs-spi';
+import { HttpWorkspaceClient } from '../providers/http-workspace-client';
+import { createRemoteFsMiddleware } from '../middleware/remote-fs-middleware';
+import { createStoreSyncMiddleware } from '../middleware/store-sync-middleware';
+import { STORE_MANAGER_TOKEN, STORE_EXTENSIONS_TOKEN, } from '@hamak/ui-store-api';
+/**
+ * Create Remote FS plugin
+ *
+ * This plugin provides remote filesystem capabilities through HTTP API.
+ * It registers two middleware:
+ * - Remote FS Middleware: Handles remote operations via HTTP client
+ * - Store Sync Middleware: Synchronizes remote data to Redux Store FS
+ *
+ * @param config Plugin configuration
+ * @returns PluginModule for microkernel integration
+ *
+ * @example
+ * ```typescript
+ * import { Pathway } from '@hamak/shared-utils';
+ * import { createRemoteFsPlugin } from '@hamak/ui-remote-fs-impl';
+ *
+ * const plugin = createRemoteFsPlugin({
+ *   workspaceId: '0',
+ *   mountPoint: Pathway.ofRoot().resolve('remote'),
+ *   baseUrl: 'http://localhost:3000/api',
+ *   autoReload: true
+ * });
+ * ```
+ */
+export function createRemoteFsPlugin(config) {
+    let workspaceClient;
+    let pathTranslator;
+    let storeManager;
+    const log = (message, ...args) => {
+        if (config.debug) {
+            console.log(`[ui-remote-fs] ${message}`, ...args);
+        }
+    };
+    return {
+        async initialize(ctx) {
+            log('Initializing plugin...');
+            // Create or use custom workspace client
+            if (config.customClient) {
+                workspaceClient = config.customClient;
+                log('Using custom workspace client');
+            }
+            else {
+                const clientConfig = {
+                    workspaceId: config.workspaceId,
+                    baseUrl: config.baseUrl,
+                    timeout: config.timeout,
+                };
+                workspaceClient = new HttpWorkspaceClient(clientConfig);
+                log('Created HTTP workspace client', { baseUrl: config.baseUrl, workspaceId: config.workspaceId });
+            }
+            // Create or use custom path translator
+            if (config.customPathTranslator) {
+                pathTranslator = config.customPathTranslator;
+                log('Using custom path translator');
+            }
+            else {
+                pathTranslator = new PathTranslator(config.mountPoint);
+                log('Created path translator', { mountPoint: config.mountPoint.getSegments() });
+            }
+            // Register services via DI
+            ctx.provide({ provide: WORKSPACE_CLIENT_TOKEN, useValue: workspaceClient });
+            ctx.provide({ provide: PATH_TRANSLATOR_TOKEN, useValue: pathTranslator });
+            // Note: IRemoteFsService implementation will be added in future phases
+            // ctx.provide({ provide: REMOTE_FS_SERVICE_TOKEN, useValue: remoteFsService });
+            log('Plugin initialized');
+        },
+        async activate(ctx) {
+            log('Activating plugin...');
+            // Resolve store manager from DI
+            try {
+                storeManager = ctx.resolve(STORE_MANAGER_TOKEN);
+            }
+            catch (error) {
+                throw new Error('[ui-remote-fs] Store manager not found. Ensure @hamak/ui-store plugin is loaded before ui-remote-fs.');
+            }
+            // Get file system adapter from store
+            const fileSystemAdapter = storeManager.getFileSystemAdapter();
+            if (!fileSystemAdapter) {
+                throw new Error('[ui-remote-fs] File system adapter not found in store manager.');
+            }
+            // Get store extensions collector
+            const extensionsCollector = ctx.resolve(STORE_EXTENSIONS_TOKEN);
+            // Create and register remote FS middleware
+            const remoteFsMiddleware = createRemoteFsMiddleware({
+                client: workspaceClient,
+                pathTranslator,
+                onError: (error, action) => {
+                    log('Remote FS error:', error, action);
+                    ctx.hooks.emit('ui-remote-fs:error', { error, action });
+                },
+                onSuccess: (result, action) => {
+                    log('Remote FS success:', action.type);
+                    ctx.hooks.emit('ui-remote-fs:success', { result, action });
+                },
+            });
+            // Create and register store sync middleware
+            const storeSyncMiddleware = createStoreSyncMiddleware({
+                fileSystemAdapter,
+                pathTranslator,
+                autoReload: config.autoReload,
+                transformContent: config.transformContent,
+            });
+            // Register middleware with store extensions
+            const middlewareExtensions = [
+                {
+                    id: 'remote-fs',
+                    middleware: remoteFsMiddleware,
+                    priority: 100,
+                    plugin: 'ui-remote-fs',
+                    description: 'Handles remote filesystem operations via HTTP',
+                },
+                {
+                    id: 'store-sync',
+                    middleware: storeSyncMiddleware,
+                    priority: 50,
+                    plugin: 'ui-remote-fs',
+                    description: 'Synchronizes remote FS to Redux Store FS',
+                },
+            ];
+            extensionsCollector.register('ui-remote-fs:middleware', {
+                middleware: middlewareExtensions,
+            });
+            log('Middleware registered');
+            // Emit ready event
+            ctx.hooks.emit('ui-remote-fs:ready', {
+                workspaceClient,
+                pathTranslator,
+                mountPoint: config.mountPoint,
+            });
+            log('Plugin activated');
+        },
+        async deactivate() {
+            log('Plugin deactivated');
+            // Cleanup if needed
+        },
+    };
+}
+export default createRemoteFsPlugin;

package/dist/providers/http-workspace-client.d.ts

@@ -0,0 +1,99 @@
+/**
+ * HTTP Workspace Client
+ *
+ * HTTP-based implementation of IWorkspaceClient using Axios.
+ * Migrated from amk/libs/server/ws/ws-client/src/lib/server-ws-ws-client.ts
+ */
+import { AxiosInstance } from 'axios';
+import { IWorkspaceClient } from '@hamak/ui-remote-fs-spi';
+import { FileInfo } from '@hamak/shared-utils';
+/**
+ * Configuration for HTTP workspace client
+ */
+export interface HttpWorkspaceClientConfig {
+    /**
+     * Base URL for the API (e.g., 'http://localhost:3000/api')
+     * If not provided, defaults to current origin + '/api'
+     */
+    baseUrl?: string;
+    /**
+     * Workspace identifier
+     */
+    workspaceId: string;
+    /**
+     * Request timeout in milliseconds
+     * Default: 30000 (30 seconds)
+     */
+    timeout?: number;
+    /**
+     * Custom axios instance (for advanced configuration)
+     */
+    axiosInstance?: AxiosInstance;
+}
+/**
+ * HTTP-based implementation of IWorkspaceClient
+ *
+ * This implementation uses Axios to communicate with a REST API backend.
+ * Supports configurable base URL, timeout, and custom axios instances.
+ *
+ * @example
+ * ```typescript
+ * const client = new HttpWorkspaceClient({
+ *   workspaceId: '0',
+ *   baseUrl: 'http://localhost:3000/api'
+ * });
+ *
+ * const files = await client.listFiles(['folder', 'subfolder']);
+ * ```
+ */
+export declare class HttpWorkspaceClient implements IWorkspaceClient {
+    private readonly workspaceId;
+    private readonly baseUrl;
+    private readonly axios;
+    constructor(config: HttpWorkspaceClientConfig);
+    /**
+     * Format path segments to URL path string
+     */
+    private formatPath;
+    /**
+     * Handle axios errors and convert to ErrorObject
+     */
+    private handleError;
+    /**
+     * Serialize content to string for transmission
+     */
+    private serializeContent;
+    /**
+     * List files and directories at the specified path
+     */
+    listFiles(path: string[]): Promise<FileInfo[]>;
+    /**
+     * Create a directory at the specified path
+     */
+    createDirectory(path: string[]): Promise<FileInfo>;
+    /**
+     * Read a file's metadata and content
+     */
+    readFile(path: string[]): Promise<FileInfo>;
+    /**
+     * Write or update a file's content (uses PUT method)
+     */
+    putFile(path: string[], content: any): Promise<FileInfo>;
+    /**
+     * Delete a file or directory
+     */
+    deleteFile(path: string[]): Promise<FileInfo>;
+    /**
+     * Get the workspace ID
+     */
+    getWorkspaceId(): string;
+    /**
+     * Get the base URL
+     */
+    getBaseUrl(): string;
+}
+/**
+ * Factory function to create HTTP workspace client with default configuration
+ */
+export declare function createHttpWorkspaceClient(workspaceId: string, baseUrl?: string): HttpWorkspaceClient;
+//# sourceMappingURL=http-workspace-client.d.ts.map

package/dist/providers/http-workspace-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-workspace-client.d.ts","sourceRoot":"","sources":["../../src/providers/http-workspace-client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAc,EAAE,aAAa,EAAc,MAAM,OAAO,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG/C;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,mBAAoB,YAAW,gBAAgB;IAC1D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;gBAE1B,MAAM,EAAE,yBAAyB;IAmB7C;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,WAAW;IA6BnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;OAEG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAYpD;;OAEG;IACG,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;IAYxD;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;IAYjD;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;IAc9D;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;IAYnD;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,UAAU,IAAI,MAAM;CAGrB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,GACf,mBAAmB,CAKrB"}

package/dist/providers/http-workspace-client.js

@@ -0,0 +1,171 @@
+/**
+ * HTTP Workspace Client
+ *
+ * HTTP-based implementation of IWorkspaceClient using Axios.
+ * Migrated from amk/libs/server/ws/ws-client/src/lib/server-ws-ws-client.ts
+ */
+import axios from 'axios';
+/**
+ * HTTP-based implementation of IWorkspaceClient
+ *
+ * This implementation uses Axios to communicate with a REST API backend.
+ * Supports configurable base URL, timeout, and custom axios instances.
+ *
+ * @example
+ * ```typescript
+ * const client = new HttpWorkspaceClient({
+ *   workspaceId: '0',
+ *   baseUrl: 'http://localhost:3000/api'
+ * });
+ *
+ * const files = await client.listFiles(['folder', 'subfolder']);
+ * ```
+ */
+export class HttpWorkspaceClient {
+    constructor(config) {
+        this.workspaceId = config.workspaceId;
+        // Default base URL to current origin if not provided
+        this.baseUrl = config.baseUrl ||
+            (typeof globalThis !== 'undefined' && 'location' in globalThis
+                ? `${globalThis.location.protocol}//${globalThis.location.host}/api`
+                : '/api');
+        // Use provided axios instance or create new one
+        this.axios = config.axiosInstance || axios.create({
+            baseURL: this.baseUrl,
+            timeout: config.timeout || 30000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    /**
+     * Format path segments to URL path string
+     */
+    formatPath(path) {
+        return path.join('/');
+    }
+    /**
+     * Handle axios errors and convert to ErrorObject
+     */
+    handleError(error) {
+        if (axios.isAxiosError(error)) {
+            const axiosError = error;
+            // Try to extract error from response
+            if (axiosError.response?.data?.error) {
+                throw axiosError.response.data.error;
+            }
+            // Create error from axios error
+            const errorObj = {
+                code: axiosError.code || 'UNKNOWN',
+                message: axiosError.message || 'Unknown error occurred',
+                params: {
+                    status: axiosError.response?.status,
+                    statusText: axiosError.response?.statusText,
+                },
+            };
+            throw errorObj;
+        }
+        // Handle non-axios errors
+        const errorObj = {
+            code: 'UNKNOWN',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        };
+        throw errorObj;
+    }
+    /**
+     * Serialize content to string for transmission
+     */
+    serializeContent(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return JSON.stringify(content);
+    }
+    /**
+     * List files and directories at the specified path
+     */
+    async listFiles(path) {
+        try {
+            const formattedPath = this.formatPath(path);
+            const response = await this.axios.get(`/workspaces/${this.workspaceId}/files/${formattedPath}`);
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Create a directory at the specified path
+     */
+    async createDirectory(path) {
+        try {
+            const formattedPath = this.formatPath(path);
+            const response = await this.axios.post(`/workspaces/${this.workspaceId}/mkdir/${formattedPath}`);
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Read a file's metadata and content
+     */
+    async readFile(path) {
+        try {
+            const formattedPath = this.formatPath(path);
+            const response = await this.axios.get(`/workspaces/${this.workspaceId}/read/${formattedPath}`);
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Write or update a file's content (uses PUT method)
+     */
+    async putFile(path, content) {
+        try {
+            const formattedPath = this.formatPath(path);
+            const serializedContent = this.serializeContent(content);
+            const response = await this.axios.put(`/workspaces/${this.workspaceId}/put/${formattedPath}`, { content: serializedContent });
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Delete a file or directory
+     */
+    async deleteFile(path) {
+        try {
+            const formattedPath = this.formatPath(path);
+            const response = await this.axios.delete(`/workspaces/${this.workspaceId}/delete/${formattedPath}`);
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Get the workspace ID
+     */
+    getWorkspaceId() {
+        return this.workspaceId;
+    }
+    /**
+     * Get the base URL
+     */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+}
+/**
+ * Factory function to create HTTP workspace client with default configuration
+ */
+export function createHttpWorkspaceClient(workspaceId, baseUrl) {
+    return new HttpWorkspaceClient({
+        workspaceId,
+        baseUrl,
+    });
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Remote FS Providers
+ */
+export * from './http-workspace-client';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/providers/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,yBAAyB,CAAC"}

package/dist/providers/index.js

@@ -0,0 +1,4 @@
+/**
+ * Remote FS Providers
+ */
+export * from './http-workspace-client';

package/dist/services/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Remote FS Services
+ */
+export * from './remote-fs-service';
+//# sourceMappingURL=index.d.ts.map