@hamak/ui-remote-fs-impl 0.4.6 → 0.4.16

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@hamak/ui-remote-fs-impl",
-  "version": "0.4.6",
+  "version": "0.4.16",
   "private": false,
   "type": "module",
   "description": "Remote FS Implementation - HTTP-based remote filesystem",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "sideEffects": false,
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/amah/app-framework.git",
@@ -34,18 +37,18 @@
     }
   },
   "dependencies": {
-    "@hamak/ui-remote-fs-api": "0.4.6",
-    "@hamak/ui-remote-fs-spi": "0.4.6",
-    "@hamak/ui-store-api": "0.4.1",
-    "@hamak/ui-store-impl": "0.4.1",
-    "@hamak/microkernel-api": "0.4.1",
-    "@hamak/microkernel-spi": "0.4.6",
+    "@hamak/ui-remote-fs-api": "*",
+    "@hamak/ui-remote-fs-spi": "*",
+    "@hamak/ui-store-api": "*",
+    "@hamak/ui-store-impl": "*",
+    "@hamak/microkernel-api": "*",
+    "@hamak/microkernel-spi": "*",
     "@reduxjs/toolkit": "^2.0.0",
     "axios": "^1.6.0",
     "redux": "^5.0.1"
   },
   "peerDependencies": {
-    "@hamak/shared-utils": "^0.4.2"
+    "@hamak/shared-utils": "*"
   },
   "devDependencies": {
     "typescript": "~5.4.0",

package/project.json

@@ -1,24 +0,0 @@
-{
-  "name": "@hamak/ui-remote-fs-impl",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/ui-remote-fs/ui-remote-fs-impl/src",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "nx:run-commands",
-      "outputs": ["{projectRoot}/dist"],
-      "options": {
-        "command": "tsc -p tsconfig.json && tsc -p tsconfig.es2015.json",
-        "cwd": "{projectRoot}"
-      }
-    },
-    "clean": {
-      "executor": "nx:run-commands",
-      "options": {
-        "command": "rm -rf dist",
-        "cwd": "{projectRoot}"
-      }
-    }
-  },
-  "tags": ["type:library", "scope:ui-remote-fs"]
-}

package/src/actions/index.ts

@@ -1,5 +0,0 @@
-/**
- * Remote FS Actions
- */
-
-export * from './remote-fs-actions';

package/src/actions/remote-fs-actions.ts

@@ -1,302 +0,0 @@
-/**
- * Remote FS Actions
- *
- * Action creators for remote filesystem operations.
- * Migrated from amk/libs/ui/core/remote-fs/src/lib/remote-fs-actions.ts
- */
-
-import { RemoteFsActionTypes, ErrorObject } from '@hamak/ui-remote-fs-api';
-import { FileInfo } from '@hamak/shared-utils';
-
-// Interfaces for action payloads
-export interface LsRequestAction {
-  type: RemoteFsActionTypes.LS_REQUEST;
-  payload: { path: string | string[] };
-  [key: string]: any;
-}
-
-export interface LsCompletedAction {
-  type: RemoteFsActionTypes.LS_COMPLETED;
-  payload: { data: FileInfo[]; request: LsRequestAction };
-  [key: string]: any;
-}
-
-export interface LsFailedAction {
-  type: RemoteFsActionTypes.LS_FAILED;
-  payload: { error: ErrorObject; request: LsRequestAction };
-  [key: string]: any;
-}
-
-export interface MkdirRequestAction {
-  type: RemoteFsActionTypes.MKDIR_REQUEST;
-  payload: { path: string | string[] };
-  [key: string]: any;
-}
-
-export interface MkdirCompletedAction {
-  type: RemoteFsActionTypes.MKDIR_COMPLETED;
-  payload: { data: FileInfo; request: MkdirRequestAction };
-  [key: string]: any;
-}
-
-export interface MkdirFailedAction {
-  type: RemoteFsActionTypes.MKDIR_FAILED;
-  payload: { error: ErrorObject; request: MkdirRequestAction };
-  [key: string]: any;
-}
-
-export interface GetRequestAction {
-  type: RemoteFsActionTypes.GET_REQUEST;
-  payload: { path: string | string[] };
-  [key: string]: any;
-}
-
-export interface GetCompletedAction {
-  type: RemoteFsActionTypes.GET_COMPLETED;
-  payload: { data: FileInfo; request: GetRequestAction };
-  [key: string]: any;
-}
-
-export interface GetFailedAction {
-  type: RemoteFsActionTypes.GET_FAILED;
-  payload: { error: ErrorObject; request: GetRequestAction };
-  [key: string]: any;
-}
-
-export interface PostRequestAction {
-  type: RemoteFsActionTypes.POST_REQUEST;
-  payload: { path: string | string[]; content: any };
-  [key: string]: any;
-}
-
-export interface PostCompletedAction {
-  type: RemoteFsActionTypes.POST_COMPLETED;
-  payload: { data: FileInfo; request: PostRequestAction };
-  [key: string]: any;
-}
-
-export interface PostFailedAction {
-  type: RemoteFsActionTypes.POST_FAILED;
-  payload: { error: ErrorObject; request: PostRequestAction };
-  [key: string]: any;
-}
-
-export interface PutRequestAction {
-  type: RemoteFsActionTypes.PUT_REQUEST;
-  payload: { path: string | string[]; content: any };
-  [key: string]: any;
-}
-
-export interface PutCompletedAction {
-  type: RemoteFsActionTypes.PUT_COMPLETED;
-  payload: { data: FileInfo; request: PutRequestAction };
-  [key: string]: any;
-}
-
-export interface PutFailedAction {
-  type: RemoteFsActionTypes.PUT_FAILED;
-  payload: { error: ErrorObject; request: PutRequestAction };
-  [key: string]: any;
-}
-
-export interface DeleteRequestAction {
-  type: RemoteFsActionTypes.DELETE_REQUEST;
-  payload: { path: string | string[] };
-  [key: string]: any;
-}
-
-export interface DeleteCompletedAction {
-  type: RemoteFsActionTypes.DELETE_COMPLETED;
-  payload: { data: FileInfo; request: DeleteRequestAction };
-  [key: string]: any;
-}
-
-export interface DeleteFailedAction {
-  type: RemoteFsActionTypes.DELETE_FAILED;
-  payload: { error: ErrorObject; request: DeleteRequestAction };
-  [key: string]: any;
-}
-
-/**
- * Union type for all remote FS actions
- */
-export type RemoteFsAction =
-  | LsRequestAction
-  | LsCompletedAction
-  | LsFailedAction
-  | MkdirRequestAction
-  | MkdirCompletedAction
-  | MkdirFailedAction
-  | GetRequestAction
-  | GetCompletedAction
-  | GetFailedAction
-  | PostRequestAction
-  | PostCompletedAction
-  | PostFailedAction
-  | PutRequestAction
-  | PutCompletedAction
-  | PutFailedAction
-  | DeleteRequestAction
-  | DeleteCompletedAction
-  | DeleteFailedAction;
-
-/**
- * Action factory class for creating remote filesystem actions
- */
-export class RemoteFsActionFactory {
-  public types = RemoteFsActionTypes;
-
-  // LS (List) operations
-  ofLsRequest(path: string | string[]): LsRequestAction {
-    return {
-      type: this.types.LS_REQUEST,
-      payload: { path },
-    };
-  }
-
-  ofLsCompleted(data: FileInfo[], request: LsRequestAction): LsCompletedAction {
-    return {
-      type: this.types.LS_COMPLETED,
-      payload: { data, request },
-    };
-  }
-
-  ofLsFailed(error: ErrorObject, request: LsRequestAction): LsFailedAction {
-    return {
-      type: this.types.LS_FAILED,
-      payload: { error, request },
-    };
-  }
-
-  // MKDIR (Make Directory) operations
-  ofMkdirRequest(path: string | string[]): MkdirRequestAction {
-    return {
-      type: this.types.MKDIR_REQUEST,
-      payload: { path },
-    };
-  }
-
-  ofMkdirCompleted(data: FileInfo, request: MkdirRequestAction): MkdirCompletedAction {
-    return {
-      type: this.types.MKDIR_COMPLETED,
-      payload: { data, request },
-    };
-  }
-
-  ofMkdirFailed(error: ErrorObject, request: MkdirRequestAction): MkdirFailedAction {
-    return {
-      type: this.types.MKDIR_FAILED,
-      payload: { error, request },
-    };
-  }
-
-  // GET (Read File) operations
-  ofGetRequest(path: string | string[]): GetRequestAction {
-    return {
-      type: this.types.GET_REQUEST,
-      payload: { path },
-    };
-  }
-
-  ofGetCompleted(data: FileInfo, request: GetRequestAction): GetCompletedAction {
-    return {
-      type: this.types.GET_COMPLETED,
-      payload: { data, request },
-    };
-  }
-
-  ofGetFailed(error: ErrorObject, request: GetRequestAction): GetFailedAction {
-    return {
-      type: this.types.GET_FAILED,
-      payload: { error, request },
-    };
-  }
-
-  // POST (Create File) operations
-  ofPostRequest(path: string | string[], content: any): PostRequestAction {
-    return {
-      type: this.types.POST_REQUEST,
-      payload: { path, content },
-    };
-  }
-
-  ofPostCompleted(data: FileInfo, request: PostRequestAction): PostCompletedAction {
-    return {
-      type: this.types.POST_COMPLETED,
-      payload: { data, request },
-    };
-  }
-
-  ofPostFailed(error: ErrorObject, request: PostRequestAction): PostFailedAction {
-    return {
-      type: this.types.POST_FAILED,
-      payload: { error, request },
-    };
-  }
-
-  // PUT (Update File) operations
-  ofPutRequest(path: string | string[], content: any): PutRequestAction {
-    return {
-      type: this.types.PUT_REQUEST,
-      payload: { path, content },
-    };
-  }
-
-  ofPutCompleted(data: FileInfo, request: PutRequestAction): PutCompletedAction {
-    return {
-      type: this.types.PUT_COMPLETED,
-      payload: { data, request },
-    };
-  }
-
-  ofPutFailed(error: ErrorObject, request: PutRequestAction): PutFailedAction {
-    return {
-      type: this.types.PUT_FAILED,
-      payload: { error, request },
-    };
-  }
-
-  // DELETE operations
-  ofDeleteRequest(path: string | string[]): DeleteRequestAction {
-    return {
-      type: this.types.DELETE_REQUEST,
-      payload: { path },
-    };
-  }
-
-  ofDeleteCompleted(data: FileInfo, request: DeleteRequestAction): DeleteCompletedAction {
-    return {
-      type: this.types.DELETE_COMPLETED,
-      payload: { data, request },
-    };
-  }
-
-  ofDeleteFailed(error: ErrorObject, request: DeleteRequestAction): DeleteFailedAction {
-    return {
-      type: this.types.DELETE_FAILED,
-      payload: { error, request },
-    };
-  }
-
-  /**
-   * Type guard to check if an action is a remote FS action
-   */
-  isRemoteFsAction(action: any): action is RemoteFsAction {
-    return (
-      action &&
-      typeof action === 'object' &&
-      'type' in action &&
-      Object.values(RemoteFsActionTypes).includes(action.type)
-    );
-  }
-}
-
-/**
- * Singleton instance of the action factory
- */
-export const rfsActions = new RemoteFsActionFactory();
-
-/**
- * Re-export the action types enum for convenience
- */
-export { RemoteFsActionTypes };

package/src/index.ts

@@ -1,10 +0,0 @@
-/**
- * UI Remote FS Implementation
- * HTTP-based remote filesystem implementation
- */
-
-export * from './actions';
-export * from './middleware';
-export * from './providers';
-export * from './plugin';
-export * from './services';

package/src/middleware/index.ts

@@ -1,6 +0,0 @@
-/**
- * Remote FS Middleware
- */
-
-export * from './remote-fs-middleware';
-export * from './store-sync-middleware';

package/src/middleware/remote-fs-middleware.ts

@@ -1,244 +0,0 @@
-/**
- * Remote FS Middleware
- *
- * Redux middleware for handling remote filesystem operations via HTTP client.
- * Migrated from amk/libs/ui/core/remote-fs/src/lib/remote-fs-middleware.ts
- */
-
-import { AnyAction, Middleware } from '@reduxjs/toolkit';
-import { Pathway } from '@hamak/shared-utils';
-import { IWorkspaceClient, IPathTranslator } from '@hamak/ui-remote-fs-spi';
-import { RemoteFsActionTypes, ErrorObject } from '@hamak/ui-remote-fs-api';
-import {
-  rfsActions,
-  LsRequestAction,
-  MkdirRequestAction,
-  GetRequestAction,
-  PostRequestAction,
-  PutRequestAction,
-  DeleteRequestAction,
-} from '../actions/remote-fs-actions';
-
-/**
- * Configuration for remote FS middleware
- */
-export interface RemoteFsMiddlewareConfig {
-  /**
-   * Workspace client for remote operations
-   */
-  client: IWorkspaceClient;
-
-  /**
-   * Path translator for mount point translation
-   */
-  pathTranslator: IPathTranslator;
-
-  /**
-   * Optional error handler
-   */
-  onError?: (error: ErrorObject, action: AnyAction) => void;
-
-  /**
-   * Optional success handler
-   */
-  onSuccess?: (result: any, action: AnyAction) => void;
-}
-
-/**
- * Create remote filesystem middleware
- *
- * This middleware intercepts remote FS actions and executes them via the provided
- * workspace client. It handles path translation from local mount point to remote paths.
- *
- * @param config Middleware configuration
- * @returns Redux middleware
- *
- * @example
- * ```typescript
- * const middleware = createRemoteFsMiddleware({
- *   client: new HttpWorkspaceClient({ workspaceId: '0' }),
- *   pathTranslator: new PathTranslator(Pathway.ofRoot().resolve('remote'))
- * });
- * ```
- */
-export function createRemoteFsMiddleware<S = any>(
-  config: RemoteFsMiddlewareConfig
-): Middleware<{}, S> {
-  const { client, pathTranslator, onError, onSuccess } = config;
-
-  /**
-   * Translate local path to remote path
-   */
-  const toRemotePath = (path: string | string[]): Pathway | undefined => {
-    const pathway = Array.isArray(path) ? Pathway.of(path) : Pathway.of([path]);
-    return pathTranslator.toRemotePath(pathway);
-  };
-
-  /**
-   * Handle errors and convert to ErrorObject
-   */
-  const handleError = (error: any): ErrorObject => {
-    if (error && typeof error === 'object' && 'code' in error && 'message' in error) {
-      return error as ErrorObject;
-    }
-    return {
-      code: error?.code || 'UNKNOWN',
-      message: error?.message || 'Unknown error',
-    };
-  };
-
-  const remoteFsMiddleware: Middleware<{}, S> = (store) => (next) => (action) => {
-    const result = next(action);
-    const dispatch = store.dispatch;
-    const anyAction = action as AnyAction;
-
-    switch (anyAction.type) {
-      case RemoteFsActionTypes.LS_REQUEST: {
-        const requestAction = anyAction as LsRequestAction;
-        const remotePath = toRemotePath(requestAction.payload.path);
-        if (remotePath === undefined) {
-          break;
-        }
-        void (async () => {
-          try {
-            const data = await client.listFiles(remotePath.getSegments());
-            const completedAction = rfsActions.ofLsCompleted(data, requestAction);
-            dispatch(completedAction);
-            onSuccess?.(data, completedAction);
-          } catch (error) {
-            const errorObject = handleError(error);
-            const failedAction = rfsActions.ofLsFailed(errorObject, requestAction);
-            dispatch(failedAction);
-            onError?.(errorObject, failedAction);
-          }
-        })();
-        break;
-      }
-
-      case RemoteFsActionTypes.MKDIR_REQUEST: {
-        const requestAction = anyAction as MkdirRequestAction;
-        const remotePath = toRemotePath(requestAction.payload.path);
-        if (remotePath === undefined) {
-          break;
-        }
-        void (async () => {
-          try {
-            const data = await client.createDirectory(remotePath.getSegments());
-            const completedAction = rfsActions.ofMkdirCompleted(data, requestAction);
-            dispatch(completedAction);
-            onSuccess?.(data, completedAction);
-          } catch (error) {
-            const errorObject = handleError(error);
-            const failedAction = rfsActions.ofMkdirFailed(errorObject, requestAction);
-            dispatch(failedAction);
-            onError?.(errorObject, failedAction);
-          }
-        })();
-        break;
-      }
-
-      case RemoteFsActionTypes.GET_REQUEST: {
-        const requestAction = anyAction as GetRequestAction;
-        const remotePath = toRemotePath(requestAction.payload.path);
-        if (remotePath === undefined) {
-          break;
-        }
-        void (async () => {
-          try {
-            const data = await client.readFile(remotePath.getSegments());
-            const completedAction = rfsActions.ofGetCompleted(data, requestAction);
-            dispatch(completedAction);
-            onSuccess?.(data, completedAction);
-          } catch (error) {
-            const errorObject = handleError(error);
-            const failedAction = rfsActions.ofGetFailed(errorObject, requestAction);
-            dispatch(failedAction);
-            onError?.(errorObject, failedAction);
-          }
-        })();
-        break;
-      }
-
-      case RemoteFsActionTypes.POST_REQUEST: {
-        const requestAction = anyAction as PostRequestAction;
-        const remotePath = toRemotePath(requestAction.payload.path);
-        if (remotePath === undefined) {
-          break;
-        }
-        void (async () => {
-          try {
-            const data = await client.putFile(
-              remotePath.getSegments(),
-              requestAction.payload.content
-            );
-            const completedAction = rfsActions.ofPostCompleted(data, requestAction);
-            dispatch(completedAction);
-            onSuccess?.(data, completedAction);
-          } catch (error) {
-            const errorObject = handleError(error);
-            const failedAction = rfsActions.ofPostFailed(errorObject, requestAction);
-            dispatch(failedAction);
-            onError?.(errorObject, failedAction);
-          }
-        })();
-        break;
-      }
-
-      case RemoteFsActionTypes.PUT_REQUEST: {
-        const requestAction = anyAction as PutRequestAction;
-        const remotePath = toRemotePath(requestAction.payload.path);
-        if (remotePath === undefined) {
-          break;
-        }
-        void (async () => {
-          try {
-            const data = await client.putFile(
-              remotePath.getSegments(),
-              requestAction.payload.content
-            );
-            const completedAction = rfsActions.ofPutCompleted(data, requestAction);
-            dispatch(completedAction);
-            onSuccess?.(data, completedAction);
-          } catch (error) {
-            const errorObject = handleError(error);
-            const failedAction = rfsActions.ofPutFailed(errorObject, requestAction);
-            dispatch(failedAction);
-            onError?.(errorObject, failedAction);
-          }
-        })();
-        break;
-      }
-
-      case RemoteFsActionTypes.DELETE_REQUEST: {
-        const requestAction = anyAction as DeleteRequestAction;
-        const remotePath = toRemotePath(requestAction.payload.path);
-        if (remotePath === undefined) {
-          break;
-        }
-        void (async () => {
-          try {
-            const data = await client.deleteFile(remotePath.getSegments());
-            const completedAction = rfsActions.ofDeleteCompleted(data, requestAction);
-            dispatch(completedAction);
-            onSuccess?.(data, completedAction);
-          } catch (error) {
-            const errorObject = handleError(error);
-            const failedAction = rfsActions.ofDeleteFailed(errorObject, requestAction);
-            dispatch(failedAction);
-            onError?.(errorObject, failedAction);
-          }
-        })();
-        break;
-      }
-
-      default:
-        break;
-    }
-
-    return result;
-  };
-
-  return remoteFsMiddleware;
-}
-
-export default createRemoteFsMiddleware;

package/src/middleware/store-sync-middleware.ts

@@ -1,175 +0,0 @@
-/**
- * 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 { AnyAction, Middleware } from '@reduxjs/toolkit';
-import { Pathway } from '@hamak/shared-utils';
-import { RemoteFsActionTypes } from '@hamak/ui-remote-fs-api';
-import { StoreSyncMiddlewareConfig } from '@hamak/ui-remote-fs-spi';
-import {
-  rfsActions,
-  LsCompletedAction,
-  MkdirCompletedAction,
-  GetCompletedAction,
-  PostCompletedAction,
-  PutCompletedAction,
-  DeleteCompletedAction,
-} 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<S = any>(
-  config: StoreSyncMiddlewareConfig
-): Middleware<{}, S> {
-  const { fileSystemAdapter, pathTranslator, autoReload = true, transformContent } = config;
-  const storeFsActions = fileSystemAdapter.getActions();
-
-  const storeSyncMiddleware: Middleware<{}, S> = (store) => (next) => (action) => {
-    const result = next(action);
-    const anyAction = action as AnyAction;
-
-    // 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 as LsCompletedAction;
-        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 as MkdirCompletedAction;
-        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 as GetCompletedAction;
-        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: S) => (state as any).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 as PostCompletedAction | PutCompletedAction;
-        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 as DeleteCompletedAction;
-        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/src/plugin/index.ts

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

package/src/plugin/remote-fs-plugin-factory.ts

@@ -1,238 +0,0 @@
-/**
- * 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 {
-  WORKSPACE_CLIENT_TOKEN,
-  PATH_TRANSLATOR_TOKEN,
-  REMOTE_FS_SERVICE_TOKEN,
-} from '@hamak/ui-remote-fs-api';
-import { IWorkspaceClient, IPathTranslator, PathTranslator } from '@hamak/ui-remote-fs-spi';
-import { HttpWorkspaceClient, HttpWorkspaceClientConfig } 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,
-  type StoreMiddlewareExtension,
-} from '@hamak/ui-store-api';
-
-/**
- * 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 function createRemoteFsPlugin(config: RemoteFsPluginConfig): PluginModule {
-  let workspaceClient: IWorkspaceClient;
-  let pathTranslator: IPathTranslator;
-  let storeManager: any;
-
-  const log = (message: string, ...args: any[]) => {
-    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: HttpWorkspaceClientConfig = {
-          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) as any;
-
-      // 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: StoreMiddlewareExtension[] = [
-        {
-          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/src/providers/http-workspace-client.ts

@@ -1,232 +0,0 @@
-/**
- * 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, { AxiosInstance, AxiosError } from 'axios';
-import { IWorkspaceClient } from '@hamak/ui-remote-fs-spi';
-import { FileInfo } from '@hamak/shared-utils';
-import { ErrorObject } from '@hamak/ui-remote-fs-api';
-
-/**
- * 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 class HttpWorkspaceClient implements IWorkspaceClient {
-  private readonly workspaceId: string;
-  private readonly baseUrl: string;
-  private readonly axios: AxiosInstance;
-
-  constructor(config: HttpWorkspaceClientConfig) {
-    this.workspaceId = config.workspaceId;
-
-    // Default base URL to current origin if not provided
-    this.baseUrl = config.baseUrl ||
-      (typeof globalThis !== 'undefined' && 'location' in globalThis
-        ? `${(globalThis as any).location.protocol}//${(globalThis as any).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
-   */
-  private formatPath(path: string[]): string {
-    return path.join('/');
-  }
-
-  /**
-   * Handle axios errors and convert to ErrorObject
-   */
-  private handleError(error: unknown): never {
-    if (axios.isAxiosError(error)) {
-      const axiosError = error as AxiosError<{ error?: ErrorObject }>;
-
-      // Try to extract error from response
-      if (axiosError.response?.data?.error) {
-        throw axiosError.response.data.error;
-      }
-
-      // Create error from axios error
-      const errorObj: ErrorObject = {
-        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: ErrorObject = {
-      code: 'UNKNOWN',
-      message: error instanceof Error ? error.message : 'Unknown error occurred',
-    };
-    throw errorObj;
-  }
-
-  /**
-   * Serialize content to string for transmission
-   */
-  private serializeContent(content: any): string {
-    if (typeof content === 'string') {
-      return content;
-    }
-    return JSON.stringify(content);
-  }
-
-  /**
-   * List files and directories at the specified path
-   */
-  async listFiles(path: string[]): Promise<FileInfo[]> {
-    try {
-      const formattedPath = this.formatPath(path);
-      const response = await this.axios.get<FileInfo[]>(
-        `/workspaces/${this.workspaceId}/files/${formattedPath}`
-      );
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-
-  /**
-   * Create a directory at the specified path
-   */
-  async createDirectory(path: string[]): Promise<FileInfo> {
-    try {
-      const formattedPath = this.formatPath(path);
-      const response = await this.axios.post<FileInfo>(
-        `/workspaces/${this.workspaceId}/mkdir/${formattedPath}`
-      );
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-
-  /**
-   * Read a file's metadata and content
-   */
-  async readFile(path: string[]): Promise<FileInfo> {
-    try {
-      const formattedPath = this.formatPath(path);
-      const response = await this.axios.get<FileInfo>(
-        `/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: string[], content: any): Promise<FileInfo> {
-    try {
-      const formattedPath = this.formatPath(path);
-      const serializedContent = this.serializeContent(content);
-      const response = await this.axios.put<FileInfo>(
-        `/workspaces/${this.workspaceId}/put/${formattedPath}`,
-        { content: serializedContent }
-      );
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-
-  /**
-   * Delete a file or directory
-   */
-  async deleteFile(path: string[]): Promise<FileInfo> {
-    try {
-      const formattedPath = this.formatPath(path);
-      const response = await this.axios.delete<FileInfo>(
-        `/workspaces/${this.workspaceId}/delete/${formattedPath}`
-      );
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-
-  /**
-   * Get the workspace ID
-   */
-  getWorkspaceId(): string {
-    return this.workspaceId;
-  }
-
-  /**
-   * Get the base URL
-   */
-  getBaseUrl(): string {
-    return this.baseUrl;
-  }
-}
-
-/**
- * Factory function to create HTTP workspace client with default configuration
- */
-export function createHttpWorkspaceClient(
-  workspaceId: string,
-  baseUrl?: string
-): HttpWorkspaceClient {
-  return new HttpWorkspaceClient({
-    workspaceId,
-    baseUrl,
-  });
-}

package/src/providers/index.ts

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

package/src/services/index.ts

@@ -1,5 +0,0 @@
-/**
- * Remote FS Services
- */
-
-export * from './remote-fs-service';

package/src/services/remote-fs-service.ts

@@ -1,13 +0,0 @@
-/**
- * Remote FS Service
- *
- * Service implementation for remote filesystem operations.
- * Will be implemented in future phases.
- */
-
-// Placeholder - will be implemented in future phases
-export class RemoteFsService {
-  constructor() {
-    throw new Error('Not yet implemented');
-  }
-}

package/tsconfig.es2015.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2015",
-    "module": "CommonJS",
-    "lib": ["ES2015"],
-    "skipLibCheck": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "strict": true,
-    "outDir": "./dist/es2015",
-    "rootDir": "./src",
-    "declaration": false,
-    "declarationMap": false,
-    "sourceMap": false,
-    "downlevelIteration": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "lib": ["ES2020"],
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "strict": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "allowImportingTsExtensions": false
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}