@n8n-as-code/sync 0.5.0 → 0.7.0

package/dist/services/watcher.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import EventEmitter from 'events';
-import * as chokidar from 'chokidar';
+import * as watcher from '@parcel/watcher';
 import { WorkflowSanitizer } from './workflow-sanitizer.js';
 import { HashUtils } from './hash-utils.js';
 import { WorkflowSyncStatus } from '../types.js';
@@ -18,13 +18,14 @@ import { WorkflowSyncStatus } from '../types.js';
  * Never performs synchronization actions - only observes reality.
  */
 export class Watcher extends EventEmitter {
-    watcher = null;
+    watcherSubscription = null;
     pollInterval = null;
     client;
     directory;
     pollIntervalMs;
     syncInactive;
     ignoredTags;
+    projectId;
     stateFilePath;
     isConnected = true;
     isInitializing = false;
@@ -38,6 +39,11 @@ export class Watcher extends EventEmitter {
     isPaused = new Set(); // IDs for which observation is paused
     syncInProgress = new Set(); // IDs currently being synced
     pausedFilenames = new Set(); // Filenames for which observation is paused (for workflows without ID yet)
+    // Pending operations for rename detection
+    pendingOperations = new Map();
+    // Potential renames: when we see an add event for a workflow ID that already exists,
+    // we track it here to match with subsequent unlink events
+    potentialRenames = new Map();
     // Lightweight polling cache
     remoteTimestamps = new Map(); // workflowId -> updatedAt
     constructor(client, options) {
@@ -47,10 +53,11 @@ export class Watcher extends EventEmitter {
         this.pollIntervalMs = options.pollIntervalMs;
         this.syncInactive = options.syncInactive;
         this.ignoredTags = options.ignoredTags;
+        this.projectId = options.projectId;
         this.stateFilePath = path.join(this.directory, '.n8n-state.json');
     }
     async start() {
-        if (this.watcher || this.pollInterval)
+        if (this.watcherSubscription || this.pollInterval)
             return;
         this.isInitializing = true;
         // Initial scan - throw error if connection fails on startup
@@ -76,22 +83,39 @@ export class Watcher extends EventEmitter {
             throw error;
         }
         await this.refreshLocalState();
+        // Restore persisted ID → filename mappings from state
+        // This ensures stable filename assignment even when remote workflows have duplicate names
+        this.restoreMappingsFromState();
         this.isInitializing = false;
-        // Local Watch with debounce
-        this.watcher = chokidar.watch(this.directory, {
-            ignored: [
-                /(^|[\/\\])\../, // Hidden files
-                '**/_archive/**', // Archive folder (strictly ignored)
-                '**/.n8n-state.json' // State file
-            ],
-            persistent: true,
-            ignoreInitial: true,
-            awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 } // 500ms debounce
+        // Local Watch with @parcel/watcher
+        this.watcherSubscription = await watcher.subscribe(this.directory, (err, events) => {
+            if (err) {
+                this.emit('error', err);
+                return;
+            }
+            for (const event of events) {
+                const filename = path.basename(event.path);
+                // Ignore hidden files, trash, and state file
+                if (filename.startsWith('.') || event.path.includes('.trash')) {
+                    continue;
+                }
+                switch (event.type) {
+                    case 'create':
+                    case 'update':
+                        this.onLocalChange(event.path);
+                        break;
+                    case 'delete':
+                        this.onLocalDelete(event.path);
+                        break;
+                }
+            }
+        }, {
+            ignore: [
+                '**/.trash/**',
+                '**/.n8n-state.json',
+                '**/.git/**'
+            ]
         });
-        this.watcher
-            .on('add', (p) => this.onLocalChange(p))
-            .on('change', (p) => this.onLocalChange(p))
-            .on('unlink', (p) => this.onLocalDelete(p));
         // Remote Poll
         if (this.pollIntervalMs > 0) {
             this.pollInterval = setInterval(() => this.refreshRemoteState(), this.pollIntervalMs);
@@ -99,14 +123,19 @@ export class Watcher extends EventEmitter {
         this.emit('ready');
     }
     stop() {
-        if (this.watcher) {
-            this.watcher.close();
-            this.watcher = null;
+        if (this.watcherSubscription) {
+            this.watcherSubscription.unsubscribe();
+            this.watcherSubscription = null;
         }
         if (this.pollInterval) {
             clearInterval(this.pollInterval);
             this.pollInterval = null;
         }
+        // Clean up pending operations
+        for (const op of this.pendingOperations.values()) {
+            clearTimeout(op.timeout);
+        }
+        this.pendingOperations.clear();
     }
     /**
      * Pause observation for a workflow during sync operations
@@ -152,20 +181,95 @@ export class Watcher extends EventEmitter {
         if (!filename.endsWith('.json'))
             return;
         const content = this.readJsonFile(filePath);
-        if (!content)
+        if (!content) {
             return;
+        }
+        // Check if this is a rename operation (following architectural plan)
+        const detectedWorkflowId = content.id || this.fileToIdMap.get(filename);
+        const pendingOpKey = `unlink:${detectedWorkflowId || filename}`;
+        const pendingOp = this.pendingOperations.get(pendingOpKey);
+        if (pendingOp) {
+            // Check if this is a rename based on workflow ID or filename
+            const isRenameByWorkflowId = detectedWorkflowId && pendingOp.workflowId === detectedWorkflowId;
+            const isRenameByFilename = !detectedWorkflowId && pendingOp.filename === filename;
+            if (isRenameByWorkflowId || isRenameByFilename) {
+                // This is a rename! Handle it
+                clearTimeout(pendingOp.timeout); // Cancel the deletion timeout
+                this.handleRename(pendingOp.workflowId || detectedWorkflowId || '', pendingOp.filename, filename);
+                this.pendingOperations.delete(pendingOpKey);
+                return;
+            }
+        }
         // Check if filename is paused (for workflows without ID)
         if (this.pausedFilenames.has(filename)) {
             return;
         }
-        const workflowId = content.id || this.fileToIdMap.get(filename);
+        let workflowId = content.id || this.fileToIdMap.get(filename);
         if (workflowId && (this.isPaused.has(workflowId) || this.syncInProgress.has(workflowId))) {
             return;
         }
+        // Check for duplicate ID (following architectural plan)
+        if (content.id) {
+            const existingFilename = this.idToFileMap.get(content.id);
+            if (existingFilename && existingFilename !== filename) {
+                // Check if the existing file still exists on disk
+                const existingFilePath = path.join(this.directory, existingFilename);
+                const fileExists = fs.existsSync(existingFilePath);
+                if (!fileExists) {
+                    // The existing file doesn't exist - this is likely a rename
+                    // Update mappings to point to the new filename
+                    this.fileToIdMap.delete(existingFilename);
+                    this.fileToIdMap.set(filename, content.id);
+                    this.idToFileMap.set(content.id, filename);
+                    // Emit rename event
+                    this.emit('fileRenamed', {
+                        workflowId: content.id,
+                        oldFilename: existingFilename,
+                        newFilename: filename
+                    });
+                    // Also check if there's a pending deletion for this workflow ID
+                    const pendingOpKey = `unlink:${content.id}`;
+                    const pendingOp = this.pendingOperations.get(pendingOpKey);
+                    if (pendingOp) {
+                        clearTimeout(pendingOp.timeout);
+                        this.pendingOperations.delete(pendingOpKey);
+                    }
+                }
+                else {
+                    // File exists - this could be a rename where add happened before unlink
+                    // Track as potential rename and wait for unlink event
+                    this.potentialRenames.set(content.id, {
+                        newFilename: filename,
+                        timestamp: Date.now()
+                    });
+                    // File exists - this is a DUPLICATE ID (copy-paste)
+                    // Principle: Keep ID only in the oldest file, remove from the new one
+                    // DUPLICAT DÉTECTÉ pendant le watch → supprimer l'ID du nouveau fichier
+                    // Remove ID from the new file
+                    const currentContent = this.readJsonFile(filePath);
+                    if (currentContent && currentContent.id === content.id) {
+                        delete currentContent.id;
+                        this.writeWorkflowFile(filename, currentContent);
+                        // Re-read the content without ID
+                        const newContent = this.readJsonFile(filePath);
+                        if (newContent) {
+                            const workflowId = this.fileToIdMap.get(filename);
+                            const clean = WorkflowSanitizer.cleanForHash(newContent);
+                            const hash = this.computeHash(clean);
+                            this.localHashes.set(filename, hash);
+                            this.broadcastStatus(filename, workflowId);
+                        }
+                    }
+                    return; // Stop processing this file as it's being modified
+                    // Don't return - continue processing as normal
+                    // The unlink event should come soon and trigger rename detection
+                }
+            }
+        }
         // IMPORTANT: Hash is calculated on the SANITIZED version
         // This means versionId, versionCounter, pinData, etc. are ignored
         // The file on disk can contain these fields, but they won't affect the hash
-        const clean = WorkflowSanitizer.cleanForStorage(content);
+        const clean = WorkflowSanitizer.cleanForHash(content);
         const hash = this.computeHash(clean);
         this.localHashes.set(filename, hash);
         if (workflowId) {
@@ -188,10 +292,90 @@ export class Watcher extends EventEmitter {
                 }
             }
         }
+        // Check if this is a potential rename (add happened before unlink)
+        if (workflowId) {
+            const potentialRename = this.potentialRenames.get(workflowId);
+            if (potentialRename) {
+                this.potentialRenames.delete(workflowId);
+                // Handle as rename
+                this.handleRename(workflowId, filename, potentialRename.newFilename);
+                return;
+            }
+        }
         if (workflowId && (this.isPaused.has(workflowId) || this.syncInProgress.has(workflowId))) {
             return;
         }
-        // CRITICAL: Per spec 5.3 DELETED_LOCALLY - Archive Remote to _archive/ IMMEDIATELY
+        // Schedule deletion check to detect renames (following architectural plan)
+        this.scheduleDeletionCheck(filename, workflowId);
+    }
+    scheduleDeletionCheck(filename, workflowId) {
+        const key = `unlink:${workflowId || filename}`;
+        const timeout = setTimeout(() => {
+            // After 1000ms, confirm that it's really a deletion (increased for better rename detection)
+            this.confirmDeletion(filename, workflowId);
+            this.pendingOperations.delete(key);
+        }, 1000);
+        this.pendingOperations.set(key, {
+            type: 'unlink',
+            filename,
+            workflowId,
+            timeout
+        });
+    }
+    async onLocalRename(oldPath, newPath) {
+        const oldFilename = path.basename(oldPath);
+        const newFilename = path.basename(newPath);
+        if (!oldFilename.endsWith('.json') || !newFilename.endsWith('.json')) {
+            return;
+        }
+        // Try to get workflow ID from old filename mapping
+        let workflowId = this.fileToIdMap.get(oldFilename);
+        // If not found, try to read the new file to get the workflow ID
+        if (!workflowId) {
+            const content = this.readJsonFile(newPath);
+            if (content?.id) {
+                workflowId = content.id;
+            }
+        }
+        if (!workflowId) {
+            // No workflow ID found - this is a rename of a file without ID
+            // Just update filename mappings if they exist
+            const oldHash = this.localHashes.get(oldFilename);
+            if (oldHash) {
+                this.localHashes.delete(oldFilename);
+                this.localHashes.set(newFilename, oldHash);
+            }
+            // Update fileToIdMap if old filename had a mapping
+            const mappedWorkflowId = this.fileToIdMap.get(oldFilename);
+            if (mappedWorkflowId) {
+                this.fileToIdMap.delete(oldFilename);
+                this.fileToIdMap.set(newFilename, mappedWorkflowId);
+                this.idToFileMap.set(mappedWorkflowId, newFilename);
+            }
+            // Emit rename event even without workflow ID
+            this.emit('fileRenamed', {
+                workflowId: '',
+                oldFilename,
+                newFilename
+            });
+            this.broadcastStatus(newFilename, workflowId);
+            return;
+        }
+        // We have a workflow ID - handle as a proper rename
+        this.handleRename(workflowId, oldFilename, newFilename);
+    }
+    async confirmDeletion(filename, workflowId) {
+        // Final check: is this actually a rename?
+        if (workflowId) {
+            // Check if the workflow ID appears in another file
+            const otherFilename = this.findFilenameByWorkflowId(workflowId);
+            if (otherFilename && otherFilename !== filename) {
+                // This is a rename, not a deletion!
+                this.handleRename(workflowId, filename, otherFilename);
+                return;
+            }
+        }
+        // CRITICAL: Per spec 5.3 DELETED_LOCALLY - Archive Remote to .trash/ IMMEDIATELY
         // This happens BEFORE user confirmation, to ensure we have a backup
         if (workflowId) {
             const remoteHash = this.remoteHashes.get(workflowId);
@@ -203,15 +387,14 @@ export class Watcher extends EventEmitter {
                     const remoteWorkflow = await this.client.getWorkflow(workflowId);
                     if (remoteWorkflow) {
                         // Create archive directory if it doesn't exist
-                        const archiveDir = path.join(this.directory, '.archive');
-                        if (!fs.existsSync(archiveDir)) {
-                            fs.mkdirSync(archiveDir, { recursive: true });
+                        const trashDir = path.join(this.directory, '.trash');
+                        if (!fs.existsSync(trashDir)) {
+                            fs.mkdirSync(trashDir, { recursive: true });
                         }
                         // Save to archive with timestamp
-                        const clean = WorkflowSanitizer.cleanForStorage(remoteWorkflow);
-                        const archivePath = path.join(archiveDir, `${Date.now()}_${filename}`);
+                        const clean = WorkflowSanitizer.cleanForHash(remoteWorkflow);
+                        const archivePath = path.join(trashDir, `${Date.now()}_${filename}`);
                         fs.writeFileSync(archivePath, JSON.stringify(clean, null, 2));
-                        console.log(`[Watcher] Archived remote workflow to: ${archivePath}`);
                     }
                 }
                 catch (error) {
@@ -220,8 +403,36 @@ export class Watcher extends EventEmitter {
                 }
             }
         }
-        this.localHashes.delete(filename);
+        // IMPORTANT: Broadcast status BEFORE cleaning up mappings
+        // This ensures the UI receives the DELETED_LOCALLY status with the correct workflowId
         this.broadcastStatus(filename, workflowId);
+        // Clean up local hash for deleted file
+        this.localHashes.delete(filename);
+        // CRITICAL: DO NOT delete ID→filename mappings for DELETED_LOCALLY workflows
+        // Mappings must persist to:
+        // 1. Allow file restoration with the same filename
+        // 2. Prevent other remote workflows with the same name from taking this filename
+        // Mappings are only deleted when the workflow is completely removed via removeWorkflowState()
+    }
+    handleRename(workflowId, oldFilename, newFilename) {
+        // Update mappings
+        this.fileToIdMap.delete(oldFilename);
+        this.fileToIdMap.set(newFilename, workflowId);
+        this.idToFileMap.set(workflowId, newFilename);
+        // Update local hash mapping
+        const oldHash = this.localHashes.get(oldFilename);
+        if (oldHash) {
+            this.localHashes.delete(oldFilename);
+            this.localHashes.set(newFilename, oldHash);
+        }
+        // Emit rename event
+        this.emit('fileRenamed', {
+            workflowId,
+            oldFilename,
+            newFilename
+        });
+        // Broadcast status with new filename
+        this.broadcastStatus(newFilename, workflowId);
     }
     async refreshLocalState() {
         if (!fs.existsSync(this.directory)) {
@@ -243,18 +454,87 @@ export class Watcher extends EventEmitter {
                 }
             }
         }
-        // Add/update entries for existing files
+        // First pass: collect all files and their content
+        const fileContents = [];
         for (const filename of files) {
             const filePath = path.join(this.directory, filename);
             const content = this.readJsonFile(filePath);
             if (content) {
-                const clean = WorkflowSanitizer.cleanForStorage(content);
+                const stat = fs.statSync(filePath);
+                fileContents.push({ filename, content, mtime: stat.mtimeMs });
+                const clean = WorkflowSanitizer.cleanForHash(content);
                 const hash = this.computeHash(clean);
                 this.localHashes.set(filename, hash);
-                if (content.id) {
+            }
+        }
+        // Detect and resolve duplicate IDs (following architectural plan)
+        this.resolveDuplicateIds(fileContents);
+        // Second pass: update mappings after duplicate resolution
+        // CRITICAL: Only update mappings if not already set from persisted state
+        // This prevents ID alternation when remote workflows have duplicate names
+        for (const { filename, content } of fileContents) {
+            if (content?.id) {
+                // Only update if we don't have a persisted mapping for this ID
+                if (!this.idToFileMap.has(content.id)) {
                     this.fileToIdMap.set(filename, content.id);
                     this.idToFileMap.set(content.id, filename);
                 }
+                else {
+                    // We have a persisted mapping - verify it matches the file
+                    const persistedFilename = this.idToFileMap.get(content.id);
+                    if (persistedFilename !== filename) {
+                        // The ID is in a different file than expected
+                        // This can happen if a file was renamed or copied
+                        // We need to decide: keep persisted mapping or update to new file?
+                        // For now, update the reverse mapping but keep ID mapping stable
+                        this.fileToIdMap.set(filename, content.id);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Resolve duplicate IDs in local files (following architectural plan)
+     * Principle: Keep ID only in the oldest file, remove from others
+     */
+    resolveDuplicateIds(fileContents) {
+        // Group files by workflow ID
+        const filesById = new Map();
+        for (const { filename, content, mtime } of fileContents) {
+            if (content?.id) {
+                const workflowId = content.id;
+                if (!filesById.has(workflowId)) {
+                    filesById.set(workflowId, []);
+                }
+                filesById.get(workflowId).push({ filename, mtime });
+            }
+        }
+        // For each duplicate ID, keep only in oldest file
+        for (const [workflowId, fileList] of filesById.entries()) {
+            if (fileList.length > 1) {
+                // Sort by modification time (oldest first)
+                fileList.sort((a, b) => a.mtime - b.mtime);
+                const oldestFile = fileList[0].filename;
+                const duplicates = fileList.slice(1);
+                // Remove ID from duplicate files
+                for (const { filename: dupFilename } of duplicates) {
+                    const filePath = path.join(this.directory, dupFilename);
+                    const content = this.readJsonFile(filePath);
+                    if (content) {
+                        delete content.id;
+                        fs.writeFileSync(filePath, JSON.stringify(content, null, 2));
+                        // Update local hash for the modified file
+                        const clean = WorkflowSanitizer.cleanForHash(content);
+                        const hash = this.computeHash(clean);
+                        this.localHashes.set(dupFilename, hash);
+                    }
+                }
+                // Emit event for UI (if needed)
+                this.emit('duplicateIdResolved', {
+                    workflowId,
+                    keptInFilename: oldestFile,
+                    removedFromFilenames: duplicates.map(d => d.filename)
+                });
             }
         }
     }
@@ -266,28 +546,67 @@ export class Watcher extends EventEmitter {
      */
     async refreshRemoteState() {
         try {
-            const remoteWorkflows = await this.client.getAllWorkflows();
+            const remoteWorkflows = await this.client.getAllWorkflows(this.projectId);
             this.isConnected = true;
             const currentRemoteIds = new Set();
+            // Build set of already-assigned filenames to prevent collisions
+            // A filename is "assigned" if:
+            // 1. It exists physically on disk, OR
+            // 2. It's mapped to a workflow that still exists remotely (even if DELETED_LOCALLY)
+            const assignedFilenames = new Set();
             for (const wf of remoteWorkflows) {
                 if (this.shouldIgnore(wf))
                     continue;
                 if (this.isPaused.has(wf.id) || this.syncInProgress.has(wf.id))
                     continue;
                 currentRemoteIds.add(wf.id);
-                // CRITICAL: Use ID-based mapping instead of name-based filename generation
-                // This prevents issues when filename != workflow.name
+                // CRITICAL: Use ID-based mapping with PERSISTED state as source of truth
+                // Priority order for finding filename:
+                // 1. Persisted mapping from state (most reliable for stability)
+                // 2. Memory mapping (may differ if file was renamed locally)
+                // 3. Scan local files by ID
+                // 4. Generate from name (new workflow)
                 let filename = this.idToFileMap.get(wf.id);
-                // If no mapping exists, try to find the file by scanning local files
+                // If no valid mapping, scan local files to discover/rediscover the workflow
                 if (!filename) {
                     filename = this.findFilenameByWorkflowId(wf.id);
                 }
-                // If still not found, generate filename from name (new remote workflow)
+                // Reserve this filename BEFORE checking for newworkflows
+                if (filename) {
+                    assignedFilenames.add(filename);
+                }
+                // If still not found, this is a NEW remote workflow - generate filename
                 if (!filename) {
-                    filename = `${this.safeName(wf.name)}.json`;
+                    const baseName = `${this.safeName(wf.name)}.json`;
+                    // Check if this base name is already assigned to another workflow
+                    if (assignedFilenames.has(baseName)) {
+                        // Name collision - generate unique filename with ID suffix
+                        const idSuffix = wf.id.substring(0, 8);
+                        filename = `${this.safeName(wf.name)}_${idSuffix}.json`;
+                    }
+                    else {
+                        // Name is free - use it
+                        filename = baseName;
+                    }
+                    // Mark this filename as assigned
+                    assignedFilenames.add(filename);
+                }
+                // Update mappings ONLY if this is a new workflow or filename hasn't changed
+                const previousFilename = this.idToFileMap.get(wf.id);
+                if (!previousFilename) {
+                    // New workflow - establish mapping
+                    this.idToFileMap.set(wf.id, filename);
+                    this.fileToIdMap.set(filename, wf.id);
+                }
+                else if (previousFilename !== filename) {
+                    // Filename changed - this should only happen during explicit rename
+                    // For duplicate name scenarios, we should have generated a unique name above
+                    // Update mappings
+                    this.fileToIdMap.delete(previousFilename);
+                    this.idToFileMap.set(wf.id, filename);
+                    this.fileToIdMap.set(filename, wf.id);
                 }
-                this.idToFileMap.set(wf.id, filename);
-                this.fileToIdMap.set(filename, wf.id);
+                // If previousFilename === filename, mappings are already correct - don't touch them
                 // Check if we need to fetch full content
                 const cachedTimestamp = this.remoteTimestamps.get(wf.id);
                 const needsFullFetch = !cachedTimestamp ||
@@ -296,7 +615,7 @@ export class Watcher extends EventEmitter {
                     try {
                         const fullWf = await this.client.getWorkflow(wf.id);
                         if (fullWf) {
-                            const clean = WorkflowSanitizer.cleanForStorage(fullWf);
+                            const clean = WorkflowSanitizer.cleanForHash(fullWf);
                             const hash = this.computeHash(clean);
                             this.remoteHashes.set(wf.id, hash);
                             if (wf.updatedAt) {
@@ -386,7 +705,7 @@ export class Watcher extends EventEmitter {
         if (!content) {
             throw new Error(`Cannot finalize sync: local file not found for ${workflowId}`);
         }
-        const clean = WorkflowSanitizer.cleanForStorage(content);
+        const clean = WorkflowSanitizer.cleanForHash(content);
         const computedHash = this.computeHash(clean);
         // After a successful sync, local and remote should be identical
         // Use the computed hash for both
@@ -406,9 +725,11 @@ export class Watcher extends EventEmitter {
      */
     async updateWorkflowState(id, hash) {
         const state = this.loadState();
+        const filename = this.idToFileMap.get(id) || '';
         state.workflows[id] = {
             lastSyncedHash: hash,
-            lastSyncedAt: new Date().toISOString()
+            lastSyncedAt: new Date().toISOString(),
+            filename: filename
         };
         this.saveState(state);
     }
@@ -431,6 +752,7 @@ export class Watcher extends EventEmitter {
     }
     /**
      * Load state from .n8n-state.json
+     * Does NOT restore mappings - use restoreMappingsFromState() for that
      */
     loadState() {
         if (fs.existsSync(this.stateFilePath)) {
@@ -447,6 +769,23 @@ export class Watcher extends EventEmitter {
         }
         return { workflows: {} };
     }
+    /**
+     * Restore ID→filename mappings from persisted state
+     * Should only be called once at startup and after state changes
+     */
+    restoreMappingsFromState() {
+        const state = this.loadState();
+        for (const [id, workflowState] of Object.entries(state.workflows)) {
+            const ws = workflowState;
+            if (ws.filename) {
+                // Only set if not already mapped (current session takes precedence)
+                if (!this.idToFileMap.has(id)) {
+                    this.idToFileMap.set(id, ws.filename);
+                    this.fileToIdMap.set(ws.filename, id);
+                }
+            }
+        }
+    }
     /**
      * Save state to .n8n-state.json
      */
@@ -552,49 +891,90 @@ export class Watcher extends EventEmitter {
             return null;
         }
     }
+    writeWorkflowFile(filename, content) {
+        const filePath = path.join(this.directory, filename);
+        fs.writeFileSync(filePath, JSON.stringify(content, null, 2));
+    }
     getFileToIdMap() {
         return this.fileToIdMap;
     }
     getStatusMatrix() {
         const results = new Map();
         const state = this.loadState();
+        // Get workflows with metadata for project info
+        const workflowsMap = new Map();
+        try {
+            // Read local workflows
+            for (const [filename] of this.localHashes.entries()) {
+                const filePath = path.join(this.directory, filename);
+                if (fs.existsSync(filePath)) {
+                    const content = fs.readFileSync(filePath, 'utf8');
+                    const workflow = JSON.parse(content);
+                    if (workflow.id) {
+                        workflowsMap.set(workflow.id, workflow);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.debug('[Watcher] Failed to load workflow metadata for status matrix:', error);
+        }
         // 1. Process all local files
         for (const [filename, hash] of this.localHashes.entries()) {
             const workflowId = this.fileToIdMap.get(filename);
             const status = this.calculateStatus(filename, workflowId);
+            const workflow = workflowId ? workflowsMap.get(workflowId) : undefined;
             results.set(filename, {
                 id: workflowId || '',
                 name: filename.replace('.json', ''),
                 filename: filename,
                 status: status,
-                active: true
+                active: workflow?.active ?? true,
+                projectId: workflow?.projectId,
+                projectName: workflow?.projectName,
+                homeProject: workflow?.homeProject,
+                isArchived: workflow?.isArchived ?? false
             });
         }
         // 2. Process all remote workflows not yet in results
         for (const [workflowId, remoteHash] of this.remoteHashes.entries()) {
-            const filename = this.idToFileMap.get(workflowId) || `${workflowId}.json`;
+            // Use persisted filename from state for stability
+            const persistedFilename = state.workflows[workflowId]?.filename;
+            const filename = persistedFilename || this.idToFileMap.get(workflowId) || `${workflowId}.json`;
             if (!results.has(filename)) {
                 const status = this.calculateStatus(filename, workflowId);
+                const workflow = workflowsMap.get(workflowId);
                 results.set(filename, {
                     id: workflowId,
                     name: filename.replace('.json', ''),
                     filename: filename,
                     status: status,
-                    active: true
+                    active: workflow?.active ?? true,
+                    projectId: workflow?.projectId,
+                    projectName: workflow?.projectName,
+                    homeProject: workflow?.homeProject,
+                    isArchived: workflow?.isArchived ?? false
                 });
             }
         }
         // 3. Process tracked but deleted workflows
         for (const id of Object.keys(state.workflows)) {
-            const filename = this.idToFileMap.get(id) || `${id}.json`;
+            // Use persisted filename from state for stability
+            const persistedFilename = state.workflows[id].filename;
+            const filename = persistedFilename || this.idToFileMap.get(id) || `${id}.json`;
             if (!results.has(filename)) {
                 const status = this.calculateStatus(filename, id);
+                const workflow = workflowsMap.get(id);
                 results.set(filename, {
                     id,
                     name: filename.replace('.json', ''),
                     filename,
                     status,
-                    active: true
+                    active: workflow?.active ?? true,
+                    projectId: workflow?.projectId,
+                    projectName: workflow?.projectName,
+                    homeProject: workflow?.homeProject,
+                    isArchived: workflow?.isArchived ?? false
                 });
             }
         }
@@ -621,6 +1001,42 @@ export class Watcher extends EventEmitter {
         const state = this.loadState();
         return Object.keys(state.workflows);
     }
+    /**
+     * Get all workflows with their full content including organization metadata.
+     * This reads from local files first, falls back to remote for remote-only workflows.
+     * Useful for display purposes where we need project info, archived status, etc.
+     */
+    async getAllWorkflows() {
+        const workflows = [];
+        // 1. Get all local workflows
+        for (const [filename, _] of this.localHashes.entries()) {
+            const filepath = path.join(this.directory, filename);
+            try {
+                const content = fs.readFileSync(filepath, 'utf-8');
+                const workflow = JSON.parse(content);
+                workflows.push(workflow);
+            }
+            catch (error) {
+                console.warn(`[Watcher] Failed to read local workflow ${filename}:`, error);
+            }
+        }
+        // 2. For remote-only workflows, fetch from API
+        const localIds = new Set(workflows.map(w => w.id));
+        for (const [workflowId, _] of this.remoteHashes.entries()) {
+            if (!localIds.has(workflowId)) {
+                try {
+                    const workflow = await this.client.getWorkflow(workflowId);
+                    if (workflow) {
+                        workflows.push(workflow);
+                    }
+                }
+                catch (error) {
+                    console.warn(`[Watcher] Failed to fetch remote workflow ${workflowId}:`, error);
+                }
+            }
+        }
+        return workflows;
+    }
     /**
      * Update workflow ID in state (when a workflow is re-created with a new ID)
      */