@sinoia/hubdoc-tools 1.3.5 → 1.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinoia/hubdoc-tools",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "description": "Professional command-line tool for HubDoc document management and bulk import/export",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,7 +9,6 @@
   },
   "files": [
     "dist",
-    "plugins",
     "README.md",
     "LICENSE"
   ],
@@ -28,8 +27,8 @@
   },
   "scripts": {
     "build": "npm run build:main && npm run build:plugins",
-    "build:main": "tsc --project tsconfig.main.json && tsc-alias",
-    "build:plugins": "tsc --project tsconfig.plugins.json && npm run copy:plugin-manifests",
+    "build:main": "tsc --project tsconfig.main.json && tsc-alias -p tsconfig.main.json",
+    "build:plugins": "tsc --project tsconfig.plugins.json && tsc-alias -p tsconfig.plugins.json && npm run copy:plugin-manifests",
     "copy:plugin-manifests": "for dir in plugins/*/; do name=$(basename \"$dir\"); [ -f \"$dir/plugin.json\" ] && mkdir -p \"dist/plugins/$name\" && cp \"$dir/plugin.json\" \"dist/plugins/$name/\" || true; done",
     "dev": "ts-node -r tsconfig-paths/register src/cli.ts",
     "start": "node dist/cli.js",

package/plugins/alfresco/index.ts

@@ -1,518 +0,0 @@
-import axios, { AxiosInstance } from 'axios';
-import fs from 'fs-extra';
-import path from 'path';
-import {
-  DocumentSourcePlugin,
-  DocumentSource,
-  PluginConfig,
-  ScanResult,
-  PluginImportOptions,
-  PluginExportOptions,
-  ImportResult,
-  ExportResult
-} from '../../src/types/plugins';
-
-interface AlfrescoConfig extends PluginConfig {
-  baseUrl: string;
-  username: string;
-  password: string;
-  siteId?: string;
-  folderId?: string; // Starting folder ID, defaults to root
-  includeFolders?: boolean;
-  limit?: number;
-}
-
-interface AlfrescoNode {
-  id: string;
-  name: string;
-  nodeType: string;
-  isFolder: boolean;
-  isFile: boolean;
-  createdAt: string;
-  modifiedAt: string;
-  createdByUser: {
-    id: string;
-    displayName: string;
-  };
-  modifiedByUser: {
-    id: string;
-    displayName: string;
-  };
-  content?: {
-    mimeType: string;
-    sizeInBytes: number;
-  };
-  properties?: Record<string, any>;
-  path?: {
-    name: string;
-    isComplete: boolean;
-    elements: Array<{
-      id: string;
-      name: string;
-    }>;
-  };
-}
-
-export default class AlfrescoPlugin implements DocumentSourcePlugin {
-  readonly name = 'alfresco';
-  readonly version = '1.0.0';
-  readonly description = 'Alfresco ECM document source';
-  readonly supportedOperations = ['import', 'export', 'both'] as const;
-
-  private config?: AlfrescoConfig;
-  private apiClient?: AxiosInstance;
-  private readonly apiVersion = 'alfresco/versions/1';
-
-  async testConnection(config: PluginConfig): Promise<boolean> {
-    try {
-      const client = this.createApiClient(config as AlfrescoConfig);
-      const response = await client.get('/people/-me-');
-      return response.status === 200;
-    } catch (error: any) {
-      console.error(`Alfresco connection test failed: ${error.message}`);
-      return false;
-    }
-  }
-
-  async scan(config: PluginConfig, options?: PluginImportOptions): Promise<ScanResult> {
-    this.config = config as AlfrescoConfig;
-    this.apiClient = this.createApiClient(this.config);
-
-    const sources: DocumentSource[] = [];
-    const errors: string[] = [];
-    let totalSize = 0;
-
-    try {
-      const limit = (this.config as any).limit || (options as any)?.limit;
-      console.log(`🔍 Scanning Alfresco repository${limit ? ` (limit: ${limit})` : ''}...`);
-
-      // Determine starting node ID
-      let startingNodeId = this.config.folderId || '-root-';
-      
-      // If siteId is provided, get the document library
-      if (this.config.siteId) {
-        startingNodeId = await this.getSiteDocumentLibraryId(this.config.siteId);
-      }
-
-      const nodes = await this.scanNode(startingNodeId);
-
-      let processedCount = 0;
-      for (const node of nodes) {
-        if (node.isFile && node.content) {
-          const source: DocumentSource = {
-            id: node.id,
-            name: node.name,
-            path: this.getNodePath(node),
-            size: node.content.sizeInBytes,
-            mimeType: node.content.mimeType,
-            lastModified: new Date(node.modifiedAt),
-            metadata: {
-              alfrescoId: node.id,
-              nodeType: node.nodeType,
-              createdAt: node.createdAt,
-              createdBy: node.createdByUser.displayName,
-              modifiedBy: node.modifiedByUser.displayName,
-              properties: node.properties
-            }
-          };
-
-          // Apply filters
-          if (this.shouldIncludeSource(source, options)) {
-            sources.push(source);
-            totalSize += source.size;
-            processedCount++;
-
-            // Check limit
-            if (limit && processedCount >= limit) {
-              console.log(`📏 Reached limit of ${limit} files`);
-              break;
-            }
-          }
-        }
-      }
-
-      return {
-        sources,
-        totalCount: sources.length,
-        totalSize,
-        errors
-      };
-    } catch (error: any) {
-      return {
-        sources: [],
-        totalCount: 0,
-        totalSize: 0,
-        errors: [`Alfresco scan failed: ${error.message}`]
-      };
-    }
-  }
-
-  private async scanNode(nodeId: string, parentPath: string = ''): Promise<AlfrescoNode[]> {
-    if (!this.apiClient) throw new Error('API client not initialized');
-
-    const allNodes: AlfrescoNode[] = [];
-    let skipCount = 0;
-    const maxItems = 100;
-
-    try {
-      while (true) {
-        const response = await this.apiClient.get(`/nodes/${nodeId}/children`, {
-          params: {
-            skipCount,
-            maxItems,
-            include: 'properties,path',
-            fields: 'id,name,nodeType,isFolder,isFile,createdAt,modifiedAt,createdByUser,modifiedByUser,content,properties,path'
-          }
-        });
-
-        const nodes: AlfrescoNode[] = response.data.list.entries.map((entry: any) => {
-          const node = entry.entry;
-          // Add full path information
-          (node as any).fullPath = parentPath ? `${parentPath}/${node.name}` : node.name;
-          return node;
-        });
-
-        // Process files immediately
-        const files = nodes.filter(node => node.isFile);
-        allNodes.push(...files);
-
-        // Recursively process folders if includeFolders is enabled or not specified
-        if (this.config?.includeFolders !== false) {
-          const folders = nodes.filter(node => node.isFolder);
-          for (const folder of folders) {
-            const folderPath = parentPath ? `${parentPath}/${folder.name}` : folder.name;
-            const subNodes = await this.scanNode(folder.id, folderPath);
-            allNodes.push(...subNodes);
-          }
-        }
-
-        // Check if there are more items
-        if (nodes.length < maxItems) {
-          break;
-        }
-        skipCount += maxItems;
-      }
-
-      return allNodes;
-    } catch (error: any) {
-      if (error.response?.status === 404) {
-        console.warn(`Warning: Node not found: ${nodeId}`);
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  async import(
-    config: PluginConfig,
-    sources: DocumentSource[],
-    targetDir: string,
-    options?: PluginImportOptions
-  ): Promise<ImportResult[]> {
-    this.config = config as AlfrescoConfig;
-    this.apiClient = this.createApiClient(this.config);
-
-    const results: ImportResult[] = [];
-    const batchSize = options?.batchSize || 5;
-
-    // Process in batches to respect API limits
-    for (let i = 0; i < sources.length; i += batchSize) {
-      const batch = sources.slice(i, i + batchSize);
-      
-      for (const source of batch) {
-        const result = await this.importSingle(source, targetDir);
-        results.push(result);
-        
-        // Small delay to respect rate limits
-        await this.sleep(200);
-      }
-    }
-
-    return results;
-  }
-
-  private async importSingle(source: DocumentSource, targetDir: string): Promise<ImportResult> {
-    try {
-      if (!this.apiClient) throw new Error('API client not initialized');
-
-      const targetPath = path.join(targetDir, source.path);
-      const targetDirectory = path.dirname(targetPath);
-      
-      await fs.ensureDir(targetDirectory);
-
-      // Download file content from Alfresco
-      const response = await this.apiClient.get(`/nodes/${source.id}/content`, {
-        responseType: 'stream'
-      });
-      
-      const writer = fs.createWriteStream(targetPath);
-      response.data.pipe(writer);
-
-      return new Promise((resolve) => {
-        writer.on('finish', () => {
-          resolve({
-            success: true,
-            source,
-            localPath: targetPath,
-            bytesTransferred: source.size
-          });
-        });
-
-        writer.on('error', (error) => {
-          resolve({
-            success: false,
-            source,
-            error: error.message
-          });
-        });
-      });
-    } catch (error: any) {
-      return {
-        success: false,
-        source,
-        error: error.message
-      };
-    }
-  }
-
-  async export?(
-    config: PluginConfig,
-    localSources: DocumentSource[],
-    options?: PluginExportOptions
-  ): Promise<ExportResult[]> {
-    this.config = config as AlfrescoConfig;
-    this.apiClient = this.createApiClient(this.config);
-
-    const results: ExportResult[] = [];
-    
-    // Determine target folder ID
-    let targetFolderId = this.config.folderId || '-root-';
-    if (this.config.siteId) {
-      targetFolderId = await this.getSiteDocumentLibraryId(this.config.siteId);
-    }
-
-    for (const source of localSources) {
-      try {
-        // Determine target folder for this document
-        let actualTargetFolderId = targetFolderId;
-        
-        if (options?.preserveStructure && source.path.includes('/')) {
-          const folderPath = path.dirname(source.path);
-          actualTargetFolderId = await this.createFolderStructure(folderPath, targetFolderId);
-        }
-
-        // Read local file
-        const fileContent = await fs.readFile(source.id);
-        // Normalize filename to NFC to handle accented characters consistently across platforms
-        const fileName = (options?.preserveStructure ? path.basename(source.path) : source.name).normalize('NFC');
-
-        // Upload file to Alfresco
-        const FormData = require('form-data');
-        const form = new FormData();
-        
-        form.append('filedata', fileContent, fileName);
-        form.append('name', fileName);
-        form.append('nodeType', 'cm:content');
-
-        const response = await this.apiClient!.post(`/nodes/${actualTargetFolderId}/children`, form, {
-          headers: {
-            ...form.getHeaders()
-          }
-        });
-
-        const targetPath = options?.preserveStructure ? source.path : source.name;
-
-        results.push({
-          success: true,
-          targetPath,
-          source,
-          bytesTransferred: source.size
-        });
-      } catch (error: any) {
-        results.push({
-          success: false,
-          targetPath: options?.targetPath || '',
-          source,
-          error: error.message
-        });
-      }
-    }
-
-    return results;
-  }
-
-  private async getSiteDocumentLibraryId(siteId: string): Promise<string> {
-    if (!this.apiClient) throw new Error('API client not initialized');
-
-    try {
-      const response = await this.apiClient.get(`/sites/${siteId}/containers`);
-      const containers = response.data.list.entries;
-      
-      const documentLibrary = containers.find((container: any) => 
-        container.entry.folderId === 'documentLibrary'
-      );
-
-      if (!documentLibrary) {
-        throw new Error(`Document library not found for site: ${siteId}`);
-      }
-
-      return documentLibrary.entry.id;
-    } catch (error: any) {
-      throw new Error(`Failed to get document library for site ${siteId}: ${error.message}`);
-    }
-  }
-
-  private async createFolderStructure(folderPath: string, parentId: string): Promise<string> {
-    if (!this.apiClient) throw new Error('API client not initialized');
-
-    const parts = folderPath.split('/').filter(part => part.length > 0);
-    let currentParentId = parentId;
-
-    for (const folderName of parts) {
-      // Check if folder already exists
-      try {
-        const response = await this.apiClient.get(`/nodes/${currentParentId}/children`, {
-          params: {
-            where: `(name='${folderName}' AND nodeType='cm:folder')`,
-            maxItems: 1
-          }
-        });
-
-        const existingFolder = response.data.list.entries[0];
-        
-        if (existingFolder) {
-          currentParentId = existingFolder.entry.id;
-        } else {
-          // Create new folder
-          const createResponse = await this.apiClient.post(`/nodes/${currentParentId}/children`, {
-            name: folderName,
-            nodeType: 'cm:folder'
-          });
-          currentParentId = createResponse.data.entry.id;
-        }
-      } catch (error: any) {
-        throw new Error(`Failed to create folder structure: ${error.message}`);
-      }
-    }
-
-    return currentParentId;
-  }
-
-  getConfigSchema(): Record<string, any> {
-    return {
-      type: 'object',
-      properties: {
-        baseUrl: {
-          type: 'string',
-          description: 'Alfresco base URL (e.g., http://localhost:8080/alfresco)',
-          required: true
-        },
-        username: {
-          type: 'string',
-          description: 'Alfresco username',
-          required: true
-        },
-        password: {
-          type: 'string',
-          description: 'Alfresco password',
-          required: true
-        },
-        siteId: {
-          type: 'string',
-          description: 'Alfresco site ID to scan (optional, uses repository root if not specified)',
-          required: false
-        },
-        folderId: {
-          type: 'string',
-          description: 'Starting folder ID (optional, uses site document library or root)',
-          required: false
-        },
-        includeFolders: {
-          type: 'boolean',
-          description: 'Include subfolders in scan (default: true)',
-          default: true
-        },
-        limit: {
-          type: 'number',
-          description: 'Maximum number of documents to scan (useful for testing)',
-          required: false
-        }
-      },
-      required: ['baseUrl', 'username', 'password']
-    };
-  }
-
-  async initialize(config: PluginConfig): Promise<void> {
-    this.config = config as AlfrescoConfig;
-    
-    if (!this.config.baseUrl || !this.config.username || !this.config.password) {
-      throw new Error('Alfresco base URL, username, and password are required');
-    }
-
-    this.apiClient = this.createApiClient(this.config);
-  }
-
-  async destroy(): Promise<void> {
-    this.config = undefined;
-    this.apiClient = undefined;
-  }
-
-  private createApiClient(config: AlfrescoConfig): AxiosInstance {
-    const baseURL = `${config.baseUrl.replace(/\/$/, '')}/api/-default-/public/${this.apiVersion}`;
-    
-    return axios.create({
-      baseURL,
-      auth: {
-        username: config.username,
-        password: config.password
-      },
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      timeout: 30000
-    });
-  }
-
-  private getNodePath(node: AlfrescoNode): string {
-    // Use the full path if available from scanning
-    if ((node as any).fullPath) {
-      return (node as any).fullPath;
-    }
-
-    // Construct path from path collection
-    if (node.path && node.path.isComplete) {
-      const pathParts = node.path.elements
-        .filter(element => element.name !== 'Company Home') // Skip root element
-        .map(element => element.name);
-      pathParts.push(node.name);
-      return pathParts.join('/');
-    }
-
-    return node.name;
-  }
-
-  private shouldIncludeSource(source: DocumentSource, options?: PluginImportOptions): boolean {
-    // Apply size filter
-    if (options?.filters?.maxSize && source.size > options.filters.maxSize) {
-      return false;
-    }
-
-    // Apply date range filter
-    if (options?.filters?.dateRange) {
-      const { from, to } = options.filters.dateRange;
-      if (from && source.lastModified < from) return false;
-      if (to && source.lastModified > to) return false;
-    }
-
-    // Apply MIME type filter
-    if (options?.filters?.mimeTypes && !options.filters.mimeTypes.includes(source.mimeType)) {
-      return false;
-    }
-
-    return true;
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}

package/plugins/alfresco/plugin.json

@@ -1,12 +0,0 @@
-{
-  "name": "alfresco",
-  "version": "1.0.0",
-  "description": "Alfresco document source plugin",
-  "author": "HubDoc Tools",
-  "main": "index.ts",
-  "hubdocToolVersion": "^1.0.0",
-  "dependencies": {
-    "axios": "^1.5.0",
-    "fs-extra": "^11.1.0"
-  }
-}