@lhi/n8m 0.3.3 → 1.0.1

package/dist/commands/rollback.js

@@ -0,0 +1,201 @@
+import { Args, Command, Flags } from '@oclif/core';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { theme } from '../utils/theme.js';
+import { GitService, formatCommitChoice, diffWorkflowNodes } from '../services/git.service.js';
+/**
+ * Build the interactive select choices from a list of git commits.
+ * The most-recent commit is labelled "(HEAD)" to make it easy to identify.
+ * Pure function — safe to unit test.
+ */
+export function buildRollbackChoices(commits) {
+    return commits.map((commit, index) => ({
+        name: `${formatCommitChoice(commit)}${index === 0 ? '  (HEAD)' : ''}`,
+        value: commit.hash,
+    }));
+}
+/**
+ * Build a human-readable diff preview comparing the current on-disk version
+ * of a workflow against the version about to be restored.
+ * Pure function — safe to unit test.
+ */
+export function buildRollbackPreview(currentJson, targetJson) {
+    const diff = diffWorkflowNodes(currentJson, targetJson);
+    const lines = [];
+    if (diff.added.length === 0 && diff.removed.length === 0) {
+        lines.push(`  No node changes (${diff.unchanged} node${diff.unchanged !== 1 ? 's' : ''} unchanged)`);
+    }
+    else {
+        if (diff.added.length > 0) {
+            lines.push(`  + Nodes added back:   ${diff.added.join(', ')}`);
+        }
+        if (diff.removed.length > 0) {
+            lines.push(`  - Nodes removed:      ${diff.removed.join(', ')}`);
+        }
+        if (diff.unchanged > 0) {
+            lines.push(`    Unchanged nodes:    ${diff.unchanged}`);
+        }
+    }
+    return lines.join('\n');
+}
+async function findWorkflowFiles(rootDir) {
+    const choices = [];
+    async function scan(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await scan(fullPath);
+            }
+            else if (entry.name.endsWith('.json')) {
+                const rel = path.relative(rootDir, fullPath);
+                let label = rel;
+                try {
+                    const raw = await fs.readFile(fullPath, 'utf-8');
+                    const parsed = JSON.parse(raw);
+                    if (parsed.name)
+                        label = `${parsed.name}  (${rel})`;
+                }
+                catch {
+                    // use rel as label
+                }
+                choices.push({ name: label, value: fullPath });
+            }
+        }
+    }
+    await scan(rootDir);
+    return choices;
+}
+export default class Rollback extends Command {
+    static args = {
+        workflow: Args.string({
+            description: 'Path to workflow JSON file (omit for interactive menu)',
+            required: false,
+        }),
+    };
+    static description = 'Restore a workflow to a previous git-tracked version';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> ./workflows/slack-notifier/workflow.json',
+        '<%= config.bin %> <%= command.id %> ./workflows/slack-notifier/workflow.json --deploy',
+    ];
+    static flags = {
+        instance: Flags.string({
+            char: 'i',
+            default: 'production',
+            description: 'n8n instance name (from config)',
+        }),
+        deploy: Flags.boolean({
+            char: 'd',
+            default: false,
+            description: 'Deploy the restored workflow to n8n after rollback',
+        }),
+        dir: Flags.string({
+            description: 'Directory to scan for workflows (default: ./workflows)',
+        }),
+    };
+    async run() {
+        this.log(theme.brand());
+        const { args, flags } = await this.parse(Rollback);
+        this.log(theme.header('WORKFLOW ROLLBACK'));
+        const git = new GitService(process.cwd());
+        // 1. Verify we are inside a git repo
+        if (!(await git.isGitRepo())) {
+            this.error('Not a git repository. Rollback requires git history to restore from.');
+        }
+        // 2. Resolve workflow file path
+        let workflowPath = args.workflow;
+        if (!workflowPath) {
+            const { default: select } = await import('@inquirer/select');
+            const workflowsDir = flags.dir ?? path.join(process.cwd(), 'workflows');
+            this.log(theme.agent(`Scanning ${theme.secondary(workflowsDir)} for workflows...`));
+            const choices = await findWorkflowFiles(workflowsDir);
+            if (choices.length === 0) {
+                this.error(`No workflow JSON files found in ${workflowsDir}. Pass a file path directly or use --dir to specify another directory.`);
+            }
+            workflowPath = await select({
+                message: 'Select a workflow to roll back:',
+                choices,
+                pageSize: 15,
+            });
+        }
+        // 3. Get path relative to repo root (needed for git commands)
+        const relPath = await git.getRelativePath(path.resolve(workflowPath));
+        if (!relPath) {
+            this.error(`File "${workflowPath}" is outside the git repository and cannot be rolled back.`);
+        }
+        this.log(`\n${theme.label('Workflow')} ${theme.value(workflowPath)}`);
+        this.log(theme.divider(40));
+        // 4. Load git history for this file
+        const history = await git.getFileHistory(relPath);
+        if (history.length === 0) {
+            this.error(`No git history found for "${relPath}". Commit the workflow first to enable rollback.`);
+        }
+        if (history.length === 1) {
+            this.error(`Only one commit found for "${relPath}". There is no earlier version to roll back to.`);
+        }
+        // 5. Let user pick a commit to restore
+        const { default: select } = await import('@inquirer/select');
+        const commitChoices = buildRollbackChoices(history);
+        this.log(theme.subHeader('Git History'));
+        const targetHash = await select({
+            message: 'Select the version to restore:',
+            choices: commitChoices,
+            pageSize: 15,
+        });
+        if (targetHash === history[0].hash) {
+            this.log(theme.warn('That is already the current version (HEAD). Nothing to restore.'));
+            return;
+        }
+        // 6. Preview the diff
+        this.log(theme.subHeader('Change Preview'));
+        try {
+            const currentContent = await fs.readFile(path.resolve(workflowPath), 'utf-8');
+            const targetContent = await git.getFileAtCommit(targetHash, relPath);
+            const currentJson = JSON.parse(currentContent);
+            const targetJson = JSON.parse(targetContent);
+            const preview = buildRollbackPreview(currentJson, targetJson);
+            this.log(preview);
+        }
+        catch {
+            this.log(theme.muted('  (Could not generate diff preview)'));
+        }
+        this.log('');
+        // 7. Confirm
+        const { default: confirm } = await import('@inquirer/confirm');
+        const selectedCommit = history.find(c => c.hash === targetHash);
+        const proceed = await confirm({
+            message: `Restore to commit ${targetHash.slice(0, 7)} — "${selectedCommit.message}"?`,
+            default: false,
+        });
+        if (!proceed) {
+            this.log(theme.muted('Rollback cancelled.'));
+            return;
+        }
+        // 8. Restore — write file content from target commit, do NOT run git checkout
+        this.log(theme.agent('Restoring file...'));
+        const restoredContent = await git.getFileAtCommit(targetHash, relPath);
+        await fs.writeFile(path.resolve(workflowPath), restoredContent, 'utf-8');
+        this.log(theme.done(`Restored "${relPath}" to ${targetHash.slice(0, 7)} — "${selectedCommit.message}"`));
+        // 9. Optionally deploy
+        if (flags.deploy) {
+            this.log(theme.info('Deploying restored workflow to n8n...'));
+            try {
+                await this.config.runCommand('deploy', [path.resolve(workflowPath), '--instance', flags.instance]);
+            }
+            catch (err) {
+                this.log(theme.error(`Deploy failed: ${err.message}`));
+                this.log(theme.muted('The file has been restored locally. Run `n8m deploy` manually to push it.'));
+            }
+        }
+        else {
+            this.log(theme.muted(`  Run \`n8m deploy ${workflowPath}\` to push the restored version to n8n.`));
+        }
+    }
+}

package/dist/fixture-schema.json

@@ -0,0 +1,162 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://n8m.dev/fixture-schema.json",
+  "title": "WorkflowFixture",
+  "description": "n8m fixture file — captures a real n8n execution for offline testing and replay.",
+  "type": "object",
+  "required": ["version", "workflowId", "workflowName", "workflow", "execution"],
+  "additionalProperties": true,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "JSON Schema reference for editor autocomplete."
+    },
+    "version": {
+      "const": "1.0",
+      "description": "Fixture format version. Always \"1.0\"."
+    },
+    "capturedAt": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 timestamp of when the fixture was captured."
+    },
+    "workflowId": {
+      "type": "string",
+      "description": "The n8n workflow ID this fixture was captured from."
+    },
+    "workflowName": {
+      "type": "string",
+      "description": "Human-readable workflow name."
+    },
+    "workflow": {
+      "type": "object",
+      "description": "Full n8n workflow JSON (nodes, connections, settings, etc.).",
+      "required": ["nodes", "connections"],
+      "additionalProperties": true,
+      "properties": {
+        "name": { "type": "string" },
+        "nodes": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["name", "type"],
+            "properties": {
+              "id": { "type": "string" },
+              "name": { "type": "string", "description": "Unique node name within this workflow." },
+              "type": { "type": "string", "description": "e.g. n8n-nodes-base.code" },
+              "typeVersion": { "type": "number" },
+              "position": { "type": "array", "items": { "type": "number" }, "minItems": 2, "maxItems": 2 },
+              "parameters": { "type": "object", "additionalProperties": true }
+            }
+          }
+        },
+        "connections": {
+          "type": "object",
+          "description": "Maps source node names to their output connections.",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "main": {
+                "type": "array",
+                "items": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "node": { "type": "string" },
+                      "type": { "type": "string" },
+                      "index": { "type": "number" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "execution": {
+      "type": "object",
+      "description": "The captured n8n execution result.",
+      "required": ["status", "data"],
+      "additionalProperties": true,
+      "properties": {
+        "id": { "type": "string" },
+        "status": {
+          "type": "string",
+          "enum": ["success", "error", "crashed", "waiting", "running"],
+          "description": "Final execution status."
+        },
+        "startedAt": { "type": "string", "format": "date-time" },
+        "data": {
+          "type": "object",
+          "required": ["resultData"],
+          "properties": {
+            "resultData": {
+              "type": "object",
+              "required": ["runData"],
+              "properties": {
+                "error": {
+                  "description": "Top-level execution error, if any. null on success.",
+                  "oneOf": [
+                    { "type": "null" },
+                    {
+                      "type": "object",
+                      "additionalProperties": true,
+                      "properties": {
+                        "message": { "type": "string" },
+                        "description": { "type": "string" },
+                        "node": {
+                          "description": "Name of the node that failed.",
+                          "oneOf": [
+                            { "type": "string" },
+                            {
+                              "type": "object",
+                              "properties": {
+                                "name": { "type": "string" },
+                                "type": { "type": "string" }
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                },
+                "runData": {
+                  "type": "object",
+                  "description": "Per-node output data. Keys are exact node names.",
+                  "additionalProperties": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "additionalProperties": true,
+                      "properties": {
+                        "json": {
+                          "type": "object",
+                          "additionalProperties": true,
+                          "description": "The node's output JSON data."
+                        },
+                        "binary": {
+                          "type": "object",
+                          "additionalProperties": true,
+                          "description": "Binary field metadata, if any."
+                        },
+                        "error": {
+                          "type": "object",
+                          "additionalProperties": true,
+                          "description": "Node-level error, if this node failed."
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/dist/help.d.ts

@@ -0,0 +1,6 @@
+import { Help } from '@oclif/core';
+import type { Command } from '@oclif/core';
+export default class CustomHelp extends Help {
+    protected showRootHelp(): Promise<void>;
+    showCommandHelp(command: Command.Loadable): Promise<void>;
+}

package/dist/help.js

@@ -0,0 +1,12 @@
+import { Help } from '@oclif/core';
+import { theme } from './utils/theme.js';
+export default class CustomHelp extends Help {
+    async showRootHelp() {
+        this.log(theme.brand());
+        await super.showRootHelp();
+    }
+    async showCommandHelp(command) {
+        this.log(theme.brand());
+        await super.showCommandHelp(command);
+    }
+}